24 #include <openssl/opensslv.h>
28 #include <tdeconfig.h>
29 #include <kstaticdeleter.h>
36 #define STRINGIFY(x) #x
38 #define GET_CRYPTOLIB_SYMBOL(a) ((_cryptoLib->hasSymbol(a)) ? _cryptoLib->symbol(a) : NULL)
39 #define GET_SSLLIB_SYMBOL(a) ((_sslLib->hasSymbol(a)) ? _sslLib->symbol(a) : NULL)
42 #if !defined(OPENSSL_INIT_ADD_ALL_CIPHERS)
43 # define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L
44 # define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L
45 # define OPENSSL_INIT_LOAD_CONFIG 0x00000040L
50 static int (*K_SSL_connect) (SSL *) = 0L;
51 static int (*K_SSL_accept) (SSL *) = 0L;
52 static int (*K_SSL_read) (SSL *,
void *, int) = 0L;
53 static int (*K_SSL_write) (SSL *,
const void *, int) = 0L;
54 static SSL *(*K_SSL_new) (SSL_CTX *) = 0L;
55 static void (*K_SSL_free) (SSL *) = 0L;
56 static int (*K_SSL_shutdown) (SSL *) = 0L;
57 static SSL_CTX *(*K_SSL_CTX_new)(SSL_METHOD *) = 0L;
58 static void (*K_SSL_CTX_free) (SSL_CTX *) = 0L;
59 static int (*K_SSL_set_fd) (SSL *, int) = 0L;
60 static int (*K_SSL_pending) (SSL *) = 0L;
61 static int (*K_SSL_peek) (SSL *,
void *, int) = 0L;
62 static int (*K_SSL_CTX_set_cipher_list)(SSL_CTX *,
const char *) = 0L;
63 static void (*K_SSL_CTX_set_verify)(SSL_CTX *, int,
64 int (*)(int, X509_STORE_CTX *)) = 0L;
65 static int (*K_SSL_use_certificate)(SSL *, X509 *) = 0L;
66 static SSL_CIPHER *(*K_SSL_get_current_cipher)(SSL *) = 0L;
67 static long (*K_SSL_set_options)(SSL *ssl,
long options) = 0L;
68 static int (*K_SSL_session_reused)(SSL *ssl) = 0L;
69 static long (*K_SSL_ctrl) (SSL *,int, long,
void *) = 0L;
70 static int (*K_RAND_egd) (
const char *) = 0L;
71 static const char* (*K_RAND_file_name) (
char *, size_t) = 0L;
72 static int (*K_RAND_load_file) (
const char *, long) = 0L;
73 static int (*K_RAND_write_file) (
const char *) = 0L;
74 static SSL_METHOD * (*K_TLSv1_client_method) () = 0L;
75 static SSL_METHOD * (*K_SSLv2_client_method) () = 0L;
76 static SSL_METHOD * (*K_SSLv3_client_method) () = 0L;
77 static SSL_METHOD * (*K_TLS_client_method) () = 0L;
78 static X509 * (*K_SSL_get_peer_certificate) (SSL *) = 0L;
79 static int (*K_SSL_CIPHER_get_bits) (SSL_CIPHER *,
int *) = 0L;
80 static char * (*K_SSL_CIPHER_get_version) (SSL_CIPHER *) = 0L;
81 static const char * (*K_SSL_CIPHER_get_name) (SSL_CIPHER *) = 0L;
82 static char * (*K_SSL_CIPHER_description) (SSL_CIPHER *,
char *, int) = 0L;
83 static X509 * (*K_d2i_X509) (X509 **,
unsigned char **,long) = 0L;
84 static X509_CRL * (*K_d2i_X509_CRL) (X509_CRL **,
unsigned char **,long) = 0L;
85 static int (*K_i2d_X509) (X509 *,
unsigned char **) = 0L;
86 static int (*K_X509_cmp) (X509 *, X509 *) = 0L;
87 static int (*K_X509_subject_name_cmp) (
const X509 *,
const X509 *) = 0L;
88 static void (*K_X509_STORE_CTX_free) (X509_STORE_CTX *) = 0L;
89 static int (*K_X509_verify_cert) (X509_STORE_CTX *) = 0L;
90 static X509_STORE_CTX *(*K_X509_STORE_CTX_new) (void) = 0L;
91 static void (*K_X509_STORE_free) (X509_STORE *) = 0L;
92 static X509_STORE *(*K_X509_STORE_new) (void) = 0L;
93 static void (*K_X509_free) (X509 *) = 0L;
94 static void (*K_X509_CRL_free) (X509_CRL *) = 0L;
95 static char *(*K_X509_NAME_oneline) (X509_NAME *,
char *,int) = 0L;
96 static X509_NAME *(*K_X509_get_subject_name) (X509 *) = 0L;
97 static X509_NAME *(*K_X509_get_issuer_name) (X509 *) = 0L;
98 static X509_LOOKUP *(*K_X509_STORE_add_lookup) (X509_STORE *, X509_LOOKUP_METHOD *) = 0L;
99 static X509_LOOKUP_METHOD *(*K_X509_LOOKUP_file)(void) = 0L;
100 static void (*K_X509_LOOKUP_free)(X509_LOOKUP *) = 0L;
101 static int (*K_X509_LOOKUP_ctrl)(X509_LOOKUP *, int,
const char *, long,
char **) = 0L;
102 static void (*K_X509_STORE_CTX_init)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *) = 0L;
103 static void (*K_CRYPTO_free) (
void *) = 0L;
104 static X509* (*K_X509_dup) (X509 *) = 0L;
105 static void (*K_X509_get0_signature)(
const ASN1_BIT_STRING **psig,
106 const X509_ALGOR **palg,
const X509 *x) = 0L;
107 static BIO_METHOD *(*K_BIO_s_mem) (void) = 0L;
108 static BIO* (*K_BIO_new) (BIO_METHOD *) = 0L;
109 static BIO* (*K_BIO_new_fp) (FILE *, int) = 0L;
110 static BIO* (*K_BIO_new_mem_buf) (
void *, int) = 0L;
111 static int (*K_BIO_free) (BIO *) = 0L;
112 static long (*K_BIO_ctrl) (BIO *,int,long,
void *) = 0L;
113 static int (*K_BIO_write) (BIO *b,
const void *data,
int len) = 0L;
114 static void* (*K_BIO_get_data) (BIO *a) = 0L;
115 static int (*K_PEM_ASN1_write_bio) (int (*)(),
const char *,BIO *,
char *,
116 const EVP_CIPHER *,
unsigned char *,
int ,
117 pem_password_cb *,
void *) = 0L;
118 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
119 static int (*K_ASN1_item_i2d_fp)(ASN1_ITEM *,FILE *,
unsigned char *) = 0L;
120 static ASN1_ITEM *K_NETSCAPE_X509_it = 0L;
122 static ASN1_METHOD* (*K_X509_asn1_meth) (void) = 0L;
123 static int (*K_ASN1_i2d_fp)(int (*)(),FILE *,
unsigned char *) = 0L;
124 static int (*K_i2d_ASN1_HEADER)(ASN1_HEADER *,
unsigned char **) = 0L;
126 static int (*K_X509_print_fp) (FILE *, X509*) = 0L;
127 static int (*K_i2d_PKCS12) (PKCS12*,
unsigned char**) = 0L;
128 static int (*K_i2d_PKCS12_fp) (FILE *, PKCS12*) = 0L;
129 static int (*K_PKCS12_newpass) (PKCS12*,
char*,
char*) = 0L;
130 static PKCS12* (*K_d2i_PKCS12_fp) (FILE*, PKCS12**) = 0L;
131 static PKCS12* (*K_PKCS12_new) (void) = 0L;
132 static void (*K_PKCS12_free) (PKCS12 *) = 0L;
133 static int (*K_PKCS12_parse) (PKCS12*,
const char *, EVP_PKEY**,
134 X509**, STACK_OF(X509)**) = 0L;
135 static void (*K_EVP_PKEY_free) (EVP_PKEY *) = 0L;
136 static EVP_PKEY* (*K_EVP_PKEY_new) () = 0L;
137 static int (*K_EVP_PKEY_base_id)(
const EVP_PKEY *pkey) = 0L;
138 static RSA* (*K_EVP_PKEY_get0_RSA)(EVP_PKEY *pkey) = 0L;
139 static DSA* (*K_EVP_PKEY_get0_DSA)(EVP_PKEY *pkey) = 0L;
140 static void (*K_X509_REQ_free) (X509_REQ *) = 0L;
141 static X509_REQ* (*K_X509_REQ_new) () = 0L;
142 static int (*K_SSL_CTX_use_PrivateKey) (SSL_CTX*, EVP_PKEY*) = 0L;
143 static int (*K_SSL_CTX_use_certificate) (SSL_CTX*, X509*) = 0L;
144 static int (*K_SSL_get_error) (SSL*, int) = 0L;
145 static STACK_OF(X509)* (*K_SSL_get_peer_cert_chain) (SSL*) = 0L;
146 static void (*K_X509_STORE_CTX_set0_untrusted) (X509_STORE_CTX *, STACK_OF(X509)*) = 0L;
147 static void (*K_X509_STORE_CTX_set_purpose) (X509_STORE_CTX *, int) = 0L;
148 static void (*K_sk_free) (STACK*) = 0L;
149 static int (*K_sk_num) (STACK*) = 0L;
150 static char* (*K_sk_pop) (STACK*) = 0L;
151 static char* (*K_sk_value) (STACK*, int) = 0L;
152 static STACK* (*K_sk_new) (int (*)()) = 0L;
153 static int (*K_sk_push) (STACK*,
char*) = 0L;
154 static STACK* (*K_sk_dup) (
const STACK *) = 0L;
155 static char * (*K_i2s_ASN1_INTEGER) (X509V3_EXT_METHOD *, ASN1_INTEGER *) =0L;
156 static ASN1_INTEGER * (*K_X509_get_serialNumber) (X509 *) = 0L;
157 static EVP_PKEY *(*K_X509_get_pubkey)(X509 *) = 0L;
158 static int (*K_i2d_PublicKey)(EVP_PKEY *,
unsigned char **) = 0L;
159 static int (*K_X509_check_private_key)(X509 *, EVP_PKEY *) = 0L;
160 static char * (*K_BN_bn2hex)(
const BIGNUM *) = 0L;
161 static int (*K_X509_digest)(
const X509 *,
const EVP_MD *,
unsigned char *,
unsigned int *) = 0L;
162 static EVP_MD* (*K_EVP_md5)() = 0L;
163 static void (*K_ASN1_INTEGER_free)(ASN1_INTEGER *) = 0L;
164 static int (*K_OBJ_obj2nid)(ASN1_OBJECT *) = 0L;
165 static const char * (*K_OBJ_nid2ln)(int) = 0L;
166 static int (*K_X509_get_ext_count)(X509*) = 0L;
167 static int (*K_X509_get_ext_by_NID)(X509*, int, int) = 0L;
168 static int (*K_X509_get_ext_by_OBJ)(X509*,ASN1_OBJECT*,int) = 0L;
169 static X509_EXTENSION *(*K_X509_get_ext)(X509*,
int loc) = 0L;
170 static X509_EXTENSION *(*K_X509_delete_ext)(X509*, int) = 0L;
171 static int (*K_X509_add_ext)(X509*, X509_EXTENSION*, int) = 0L;
172 static void *(*K_X509_get_ext_d2i)(X509*, int,
int*,
int*) = 0L;
173 static char *(*K_i2s_ASN1_OCTET_STRING)(X509V3_EXT_METHOD*, ASN1_OCTET_STRING*) = 0L;
174 static int (*K_ASN1_BIT_STRING_get_bit)(ASN1_BIT_STRING*, int) = 0L;
175 static PKCS7 *(*K_PKCS7_new)() = 0L;
176 static void (*K_PKCS7_free)(PKCS7*) = 0L;
177 static void (*K_PKCS7_content_free)(PKCS7*) = 0L;
178 static int (*K_i2d_PKCS7)(PKCS7*,
unsigned char**) = 0L;
179 static PKCS7 *(*K_d2i_PKCS7)(PKCS7**,
unsigned char**,long) = 0L;
180 static int (*K_i2d_PKCS7_fp)(FILE*,PKCS7*) = 0L;
181 static PKCS7* (*K_d2i_PKCS7_fp)(FILE*,PKCS7**) = 0L;
182 static int (*K_i2d_PKCS7_bio)(BIO *bp,PKCS7 *p7) = 0L;
183 static PKCS7 *(*K_d2i_PKCS7_bio)(BIO *bp,PKCS7 **p7) = 0L;
184 static PKCS7* (*K_PKCS7_dup)(PKCS7*) = 0L;
185 static STACK_OF(X509_NAME) *(*K_SSL_load_client_CA_file)(
const char*) = 0L;
186 static STACK_OF(X509_INFO) *(*K_PEM_X509_INFO_read)(FILE*, STACK_OF(X509_INFO)*, pem_password_cb*,
void*) = 0L;
187 static char *(*K_ASN1_d2i_fp)(
char *(*)(),
char *(*)(),FILE*,
unsigned char**) = 0L;
188 static X509 *(*K_X509_new)() = 0L;
189 static int (*K_X509_PURPOSE_get_count)() = 0L;
190 static int (*K_X509_PURPOSE_get_id)(X509_PURPOSE *) = 0L;
191 static int (*K_X509_check_purpose)(X509*,int,int) = 0L;
192 static X509_PURPOSE* (*K_X509_PURPOSE_get0)(int) = 0L;
193 static int (*K_EVP_PKEY_assign)(EVP_PKEY*, int,
char*) = 0L;
194 static int (*K_X509_REQ_set_pubkey)(X509_REQ*, EVP_PKEY*) = 0L;
195 static void (*K_RSA_get0_key)(
const RSA *r,
const BIGNUM **n,
const BIGNUM **e,
const BIGNUM **d) = 0L;
196 static RSA *(*K_RSA_generate_key)(int,
unsigned long, void (*)(int,int,
void *),
void *) = 0L;
197 static void (*K_DSA_get0_pqg)(
const DSA *d,
const BIGNUM **p,
const BIGNUM **q,
const BIGNUM **g) = 0L;
198 static void (*K_DSA_get0_key)(
const DSA *d,
const BIGNUM **pub_key,
const BIGNUM **priv_key) = 0L;
199 static int (*K_i2d_X509_REQ_fp)(FILE*, X509_REQ*) = 0L;
200 static void (*K_ERR_clear_error)() = 0L;
201 static unsigned long (*K_ERR_get_error)() = 0L;
202 static void (*K_ERR_print_errors_fp)(FILE*) = 0L;
203 static PKCS7 *(*K_PKCS7_sign)(X509*, EVP_PKEY*, STACK_OF(X509)*, BIO*, int) = 0L;
204 static int (*K_PKCS7_verify)(PKCS7*,STACK_OF(X509)*,X509_STORE*,BIO*,BIO*,int) = 0L;
205 static STACK_OF(X509) *(*K_PKCS7_get0_signers)(PKCS7 *, STACK_OF(X509) *, int) = 0L;
206 static PKCS7 *(*K_PKCS7_encrypt)(STACK_OF(X509) *, BIO *, EVP_CIPHER *, int) = 0L;
207 static int (*K_PKCS7_decrypt)(PKCS7 *, EVP_PKEY *, X509 *, BIO *, int) = 0L;
208 static SSL_SESSION* (*K_SSL_get1_session)(SSL*) = 0L;
209 static void (*K_SSL_SESSION_free)(SSL_SESSION*) = 0L;
210 static int (*K_SSL_set_session)(SSL*,SSL_SESSION*) = 0L;
211 static SSL_SESSION* (*K_d2i_SSL_SESSION)(SSL_SESSION**,
unsigned char**, long) = 0L;
212 static int (*K_i2d_SSL_SESSION)(SSL_SESSION*,
unsigned char**) = 0L;
213 static STACK *(*K_X509_get1_email)(X509 *x) = 0L;
214 static void (*K_X509_email_free)(STACK *sk) = 0L;
215 static EVP_CIPHER *(*K_EVP_des_ede3_cbc)() = 0L;
216 static EVP_CIPHER *(*K_EVP_des_cbc)() = 0L;
217 static EVP_CIPHER *(*K_EVP_rc2_cbc)() = 0L;
218 static EVP_CIPHER *(*K_EVP_rc2_64_cbc)() = 0L;
219 static EVP_CIPHER *(*K_EVP_rc2_40_cbc)() = 0L;
220 static int (*K_i2d_PrivateKey_fp)(FILE*,EVP_PKEY*) = 0L;
221 static int (*K_i2d_PKCS8PrivateKey_fp)(FILE*, EVP_PKEY*,
const EVP_CIPHER*,
char*, int, pem_password_cb*,
void*) = 0L;
222 static void (*K_RSA_free)(RSA*) = 0L;
223 static EVP_CIPHER *(*K_EVP_bf_cbc)() = 0L;
224 static int (*K_X509_REQ_sign)(X509_REQ*, EVP_PKEY*,
const EVP_MD*) = 0L;
225 static int (*K_X509_NAME_add_entry_by_txt)(X509_NAME*,
char*, int,
unsigned char*, int, int, int) = 0L;
226 static X509_NAME *(*K_X509_NAME_new)() = 0L;
227 static int (*K_X509_REQ_set_subject_name)(X509_REQ*,X509_NAME*) = 0L;
228 static unsigned char *(*K_ASN1_STRING_data)(ASN1_STRING*) = 0L;
229 static int (*K_ASN1_STRING_length)(ASN1_STRING*) = 0L;
230 static STACK_OF(SSL_CIPHER) *(*K_SSL_get_ciphers)(
const SSL *ssl) = 0L;
231 static const ASN1_TIME* (*K_X509_CRL_get0_lastUpdate)(
const X509_CRL *crl) = 0L;
232 static const ASN1_TIME* (*K_X509_CRL_get0_nextUpdate)(
const X509_CRL *crl) = 0L;
233 static X509* (*K_X509_STORE_CTX_get_current_cert)(X509_STORE_CTX *ctx) = 0L;
234 static int (*K_X509_STORE_CTX_get_error)(X509_STORE_CTX *ctx) = 0L;
235 static int (*K_X509_STORE_CTX_get_error_depth)(X509_STORE_CTX *ctx) = 0L;
236 static void (*K_X509_STORE_CTX_set_error)(X509_STORE_CTX *ctx,
int s) = 0L;
237 static void (*K_X509_STORE_set_verify_cb)(X509_STORE *ctx,
238 X509_STORE_CTX_verify_cb verify_cb) = 0L;
239 static STACK_OF(X509_OBJECT)* (*K_X509_STORE_get0_objects)(X509_STORE *v) = 0L;
240 static X509_LOOKUP_TYPE (*K_X509_OBJECT_get_type)(
const X509_OBJECT *a) = 0L;
241 static X509* (*K_X509_OBJECT_get0_X509)(
const X509_OBJECT *a) = 0L;
242 static ASN1_TIME* (*K_X509_getm_notAfter)(
const X509 *x) = 0L;
243 static ASN1_TIME* (*K_X509_getm_notBefore)(
const X509 *x) = 0L;
249 return _sslLib != 0L;
254 return _cryptoLib != 0L;
265 #include <tqstring.h>
266 #include <tqstringlist.h>
268 static TQString findMostRecentLib(TQString dir, TQString name)
271 TQString filter =
"lib"+name+
".so.*";
272 TQDir d(dir, filter);
275 TQStringList l = d.entryList();
282 uint s = filter.length()-1;
283 for (TQStringList::Iterator it = l.begin(); it != l.end(); ++it) {
284 TQString numberpart = (*it).mid(s);
285 uint endmaj = numberpart.find(
'.');
289 int maj = numberpart.left(endmaj).toInt(&ok);
292 int min = numberpart.mid(endmaj+1).toInt(&ok);
295 if (maj > bestmaj || (maj == bestmaj && min > bestmin)) {
309 KOpenSSLProxy::KOpenSSLProxy() {
310 KLibLoader *ll = KLibLoader::self();
312 TQStringList libpaths, libnamesc, libnamess;
318 cfg =
new TDEConfig(
"cryptodefaults",
false,
false);
319 cfg->setGroup(
"OpenSSL");
320 TQString upath = cfg->readPathEntry(
"Path");
321 if (!upath.isEmpty())
328 TQString libname = findMostRecentLib(
"/usr/" SYSTEM_LIBDIR,
"crypto");
329 if (!libname.isNull())
330 _cryptoLib = ll->globalLibrary(libname.latin1());
332 #elif defined(__CYGWIN__)
333 libpaths <<
"/usr/bin/"
335 <<
"/usr/local/openssl/bin"
336 <<
"/opt/openssl/bin"
337 <<
"/opt/trinity/bin"
340 libnamess <<
"cygssl-0.9.7.dll"
345 libnamesc <<
"cygcrypto.dll"
351 <<
"/opt/freeware/lib/"
353 <<
"/usr/" SYSTEM_LIBDIR
"/"
354 <<
"/usr/ssl/" SYSTEM_LIBDIR
"/"
355 <<
"/usr/local/" SYSTEM_LIBDIR
"/"
356 <<
"/usr/local/openssl/" SYSTEM_LIBDIR
"/"
357 <<
"/usr/local/ssl/" SYSTEM_LIBDIR
"/"
358 <<
"/opt/openssl/" SYSTEM_LIBDIR
"/"
359 <<
"/" SYSTEM_LIBDIR
"/"
367 <<
"libssl.a(libssl.so.0)"
368 #elif defined(__APPLE__)
370 <<
"libssl.0.9.dylib"
372 #ifdef OPENSSL_SHLIB_VERSION
373 <<
"libssl.so." STRINGIFY(OPENSSL_SHLIB_VERSION)
375 #ifdef SHLIB_VERSION_NUMBER
376 <<
"libssl.so." SHLIB_VERSION_NUMBER
388 <<
"libcrypto.a(libcrypto.so.0)"
389 #elif defined(__APPLE__)
391 <<
"libcrypto.0.9.dylib"
393 #ifdef OPENSSL_SHLIB_VERSION
394 <<
"libcrypto.so." STRINGIFY(OPENSSL_SHLIB_VERSION)
396 #ifdef SHLIB_VERSION_NUMBER
397 <<
"libcrypto.so." SHLIB_VERSION_NUMBER
406 for (TQStringList::Iterator it = libpaths.begin();
407 it != libpaths.end();
409 for (TQStringList::Iterator shit = libnamesc.begin();
410 shit != libnamesc.end();
413 if (!alib.isEmpty() && !alib.endsWith(
"/"))
416 TQString tmpStr(alib.latin1());
417 tmpStr.replace(TQRegExp(
"\\(.*\\)"),
"");
418 if (!access(tmpStr.latin1(), R_OK))
419 _cryptoLib = ll->globalLibrary(alib.latin1());
420 if (_cryptoLib)
break;
422 if (_cryptoLib)
break;
427 K_X509_free = (void (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_free");
428 K_X509_CRL_free = (void (*) (X509_CRL *)) GET_CRYPTOLIB_SYMBOL(
"X509_CRL_free");
429 K_RAND_egd = (int (*)(
const char *)) GET_CRYPTOLIB_SYMBOL(
"RAND_egd");
430 K_RAND_load_file = (int (*)(
const char *, long)) GET_CRYPTOLIB_SYMBOL(
"RAND_load_file");
431 K_RAND_file_name = (
const char* (*)(
char *,
size_t)) GET_CRYPTOLIB_SYMBOL(
"RAND_file_name");
432 K_RAND_write_file = (int (*)(
const char *)) GET_CRYPTOLIB_SYMBOL(
"RAND_write_file");
433 K_CRYPTO_free = (void (*) (
void *)) GET_CRYPTOLIB_SYMBOL(
"CRYPTO_free");
434 K_d2i_X509 = (X509 * (*)(X509 **,
unsigned char **,
long)) GET_CRYPTOLIB_SYMBOL(
"d2i_X509");
435 K_d2i_X509_CRL = (X509_CRL * (*)(X509_CRL **,
unsigned char **,
long)) GET_CRYPTOLIB_SYMBOL(
"d2i_X509_CRL");
436 K_i2d_X509 = (int (*)(X509 *,
unsigned char **)) GET_CRYPTOLIB_SYMBOL(
"i2d_X509");
437 K_X509_cmp = (int (*)(X509 *, X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_cmp");
438 K_X509_subject_name_cmp = (int (*)(
const X509 *,
const X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_subject_name_cmp");
439 K_X509_STORE_CTX_new = (X509_STORE_CTX * (*) (
void)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_new");
440 K_X509_STORE_CTX_free = (void (*) (X509_STORE_CTX *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_free");
441 K_X509_verify_cert = (int (*) (X509_STORE_CTX *)) GET_CRYPTOLIB_SYMBOL(
"X509_verify_cert");
442 K_X509_STORE_new = (X509_STORE * (*) (
void)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_new");
443 K_X509_STORE_free = (void (*) (X509_STORE *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_free");
444 K_X509_NAME_oneline = (
char * (*) (X509_NAME *,
char *,
int)) GET_CRYPTOLIB_SYMBOL(
"X509_NAME_oneline");
445 K_X509_get_subject_name = (X509_NAME * (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_subject_name");
446 K_X509_get_issuer_name = (X509_NAME * (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_issuer_name");
447 K_X509_STORE_add_lookup = (X509_LOOKUP *(*) (X509_STORE *, X509_LOOKUP_METHOD *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_add_lookup");
448 K_X509_LOOKUP_file = (X509_LOOKUP_METHOD *(*)(
void)) GET_CRYPTOLIB_SYMBOL(
"X509_LOOKUP_file");
449 K_X509_LOOKUP_free = (void (*)(X509_LOOKUP *)) GET_CRYPTOLIB_SYMBOL(
"X509_LOOKUP_free");
450 K_X509_LOOKUP_ctrl = (int (*)(X509_LOOKUP *, int,
const char *, long,
char **)) GET_CRYPTOLIB_SYMBOL(
"X509_LOOKUP_ctrl");
451 K_X509_STORE_CTX_init = (void (*)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_init");
452 K_X509_dup = (X509* (*)(X509*)) GET_CRYPTOLIB_SYMBOL(
"X509_dup");
453 K_X509_get0_signature = (void (*)(
const ASN1_BIT_STRING **psig,
454 const X509_ALGOR **palg,
const X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_get0_signature");
455 K_BIO_s_mem = (BIO_METHOD *(*) (
void)) GET_CRYPTOLIB_SYMBOL(
"BIO_s_mem");
456 K_BIO_new = (BIO* (*)(BIO_METHOD *)) GET_CRYPTOLIB_SYMBOL(
"BIO_new");
457 K_BIO_new_fp = (BIO* (*)(FILE*,
int)) GET_CRYPTOLIB_SYMBOL(
"BIO_new_fp");
458 K_BIO_new_mem_buf = (BIO* (*)(
void *,
int)) GET_CRYPTOLIB_SYMBOL(
"BIO_new_mem_buf");
459 K_BIO_free = (int (*)(BIO*)) GET_CRYPTOLIB_SYMBOL(
"BIO_free");
460 K_BIO_ctrl = (long (*) (BIO *,int,long,
void *)) GET_CRYPTOLIB_SYMBOL(
"BIO_ctrl");
461 K_BIO_write = (int (*) (BIO *b,
const void *data,
int len)) GET_CRYPTOLIB_SYMBOL(
"BIO_write");
462 K_BIO_get_data = (
void* (*)(BIO *a)) GET_CRYPTOLIB_SYMBOL(
"BIO_get_data");
463 K_PEM_ASN1_write_bio = (int (*)(int (*)(),
const char *,BIO*,
char*,
const EVP_CIPHER *,
unsigned char *,
int, pem_password_cb *,
void *)) GET_CRYPTOLIB_SYMBOL(
"PEM_ASN1_write_bio");
464 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
465 K_ASN1_item_i2d_fp = (int (*)(ASN1_ITEM *, FILE*,
unsigned char *)) GET_CRYPTOLIB_SYMBOL(
"ASN1_item_i2d_fp");
466 K_NETSCAPE_X509_it = (ASN1_ITEM *) GET_CRYPTOLIB_SYMBOL(
"NETSCAPE_X509_it");
468 K_X509_asn1_meth = (ASN1_METHOD* (*)(
void)) GET_CRYPTOLIB_SYMBOL(
"X509_asn1_meth");
469 K_ASN1_i2d_fp = (int (*)(int (*)(), FILE*,
unsigned char *)) GET_CRYPTOLIB_SYMBOL(
"ASN1_i2d_fp");
470 K_i2d_ASN1_HEADER = (int (*)(ASN1_HEADER *,
unsigned char **)) GET_CRYPTOLIB_SYMBOL(
"i2d_ASN1_HEADER");
472 K_X509_print_fp = (int (*)(FILE*, X509*)) GET_CRYPTOLIB_SYMBOL(
"X509_print_fp");
473 K_i2d_PKCS12 = (int (*)(PKCS12*,
unsigned char**)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS12");
474 K_i2d_PKCS12_fp = (int (*)(FILE *, PKCS12*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS12_fp");
475 K_PKCS12_newpass = (int (*)(PKCS12*,
char*,
char*)) GET_CRYPTOLIB_SYMBOL(
"PKCS12_newpass");
476 K_d2i_PKCS12_fp = (PKCS12* (*)(FILE*, PKCS12**)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS12_fp");
477 K_PKCS12_new = (PKCS12* (*)()) GET_CRYPTOLIB_SYMBOL(
"PKCS12_new");
478 K_PKCS12_free = (void (*)(PKCS12 *)) GET_CRYPTOLIB_SYMBOL(
"PKCS12_free");
479 K_PKCS12_parse = (int (*)(PKCS12*,
const char *, EVP_PKEY**,
480 X509**, STACK_OF(X509)**)) GET_CRYPTOLIB_SYMBOL(
"PKCS12_parse");
481 K_EVP_PKEY_free = (void (*) (EVP_PKEY *)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_free");
482 K_EVP_PKEY_new = (EVP_PKEY* (*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_new");
483 K_EVP_PKEY_base_id = (int (*)(
const EVP_PKEY *pkey)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_base_id");
484 K_EVP_PKEY_get0_RSA = (RSA* (*)(EVP_PKEY *pkey)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_get0_RSA");
485 K_EVP_PKEY_get0_DSA = (DSA* (*)(EVP_PKEY *pkey)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_get0_DSA");
486 K_X509_REQ_free = (void (*)(X509_REQ*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_free");
487 K_X509_REQ_new = (X509_REQ* (*)()) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_new");
488 K_X509_STORE_CTX_set0_untrusted = (void (*)(X509_STORE_CTX *, STACK_OF(X509)*)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_set0_untrusted");
489 if (!K_X509_STORE_CTX_set0_untrusted) K_X509_STORE_CTX_set0_untrusted = (void (*)(X509_STORE_CTX *, STACK_OF(X509)*)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_set_chain");
490 K_X509_STORE_CTX_set_purpose = (void (*)(X509_STORE_CTX *, int)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_set_purpose");
491 K_sk_free = (void (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_free");
492 if (!K_sk_free) K_sk_free = (void (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_free");
493 K_sk_num = (int (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_num");
494 if (!K_sk_num) K_sk_num = (int (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_num");
495 K_sk_pop = (
char* (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_pop");
496 if (!K_sk_pop) K_sk_pop = (
char* (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_pop");
497 K_sk_value = (
char* (*) (STACK *,
int)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_value");
498 if (!K_sk_value) K_sk_value = (
char* (*) (STACK *,
int)) GET_CRYPTOLIB_SYMBOL(
"sk_value");
499 K_sk_new = (STACK* (*) (
int (*)())) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_new");
500 if (!K_sk_new) K_sk_new = (STACK* (*) (
int (*)())) GET_CRYPTOLIB_SYMBOL(
"sk_new");
501 K_sk_push = (int (*) (STACK*,
char*)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_push");
502 if (!K_sk_push) K_sk_push = (int (*) (STACK*,
char*)) GET_CRYPTOLIB_SYMBOL(
"sk_push");
503 K_sk_dup = (STACK* (*) (
const STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_dup");
504 if (!K_sk_dup) K_sk_dup = (STACK* (*) (
const STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_dup");
505 K_i2s_ASN1_INTEGER = (
char *(*) (X509V3_EXT_METHOD *, ASN1_INTEGER *)) GET_CRYPTOLIB_SYMBOL(
"i2s_ASN1_INTEGER");
506 K_X509_get_serialNumber = (ASN1_INTEGER * (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_serialNumber");
507 K_X509_get_pubkey = (EVP_PKEY *(*)(X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_pubkey");
508 K_i2d_PublicKey = (int (*)(EVP_PKEY *,
unsigned char **)) GET_CRYPTOLIB_SYMBOL(
"i2d_PublicKey");
509 K_X509_check_private_key = (int (*)(X509 *, EVP_PKEY *)) GET_CRYPTOLIB_SYMBOL(
"X509_check_private_key");
510 K_BN_bn2hex = (
char *(*)(
const BIGNUM *)) GET_CRYPTOLIB_SYMBOL(
"BN_bn2hex");
511 K_X509_digest = (int (*)(
const X509 *,
const EVP_MD *,
unsigned char *,
unsigned int *)) GET_CRYPTOLIB_SYMBOL(
"X509_digest");
512 K_EVP_md5 = (EVP_MD *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_md5");
513 K_ASN1_INTEGER_free = (void (*)(ASN1_INTEGER *)) GET_CRYPTOLIB_SYMBOL(
"ASN1_INTEGER_free");
514 K_OBJ_obj2nid = (int (*)(ASN1_OBJECT *)) GET_CRYPTOLIB_SYMBOL(
"OBJ_obj2nid");
515 K_OBJ_nid2ln = (
const char *(*)(
int)) GET_CRYPTOLIB_SYMBOL(
"OBJ_nid2ln");
516 K_X509_get_ext_count = (int (*)(X509*)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_count");
517 K_X509_get_ext_by_NID = (int (*)(X509*,int,int)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_by_NID");
518 K_X509_get_ext_by_OBJ = (int (*)(X509*,ASN1_OBJECT*,int)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_by_OBJ");
519 K_X509_get_ext = (X509_EXTENSION* (*)(X509*,
int)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext");
520 K_X509_delete_ext = (X509_EXTENSION* (*)(X509*,
int)) GET_CRYPTOLIB_SYMBOL(
"X509_delete_ext");
521 K_X509_add_ext = (int (*)(X509*,X509_EXTENSION*,int)) GET_CRYPTOLIB_SYMBOL(
"X509_add_ext");
522 K_X509_get_ext_d2i = (
void* (*)(X509*,
int,
int*,
int*)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_d2i");
523 K_i2s_ASN1_OCTET_STRING = (
char *(*)(X509V3_EXT_METHOD*,ASN1_OCTET_STRING*)) GET_CRYPTOLIB_SYMBOL(
"i2s_ASN1_OCTET_STRING");
524 K_ASN1_BIT_STRING_get_bit = (int (*)(ASN1_BIT_STRING*,int)) GET_CRYPTOLIB_SYMBOL(
"ASN1_BIT_STRING_get_bit");
525 K_PKCS7_new = (PKCS7 *(*)()) GET_CRYPTOLIB_SYMBOL(
"PKCS7_new");
526 K_PKCS7_free = (void (*)(PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_free");
527 K_PKCS7_content_free = (void (*)(PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_content_free");
528 K_i2d_PKCS7 = (int (*)(PKCS7*,
unsigned char**)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS7");
529 K_i2d_PKCS7_fp = (int (*)(FILE*,PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS7_fp");
530 K_i2d_PKCS7_bio = (int (*)(BIO *bp,PKCS7 *p7)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS7_bio");
531 K_d2i_PKCS7 = (PKCS7* (*)(PKCS7**,
unsigned char**,
long)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS7");
532 K_d2i_PKCS7_fp = (PKCS7 *(*)(FILE *,PKCS7**)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS7_fp");
533 K_d2i_PKCS7_bio = (PKCS7 *(*)(BIO *bp,PKCS7 **p7)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS7_bio");
534 K_PKCS7_dup = (PKCS7* (*)(PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_dup");
535 K_PKCS7_sign = (PKCS7 *(*)(X509*, EVP_PKEY*, STACK_OF(X509)*, BIO*, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_sign");
536 K_PKCS7_verify = (int (*)(PKCS7*,STACK_OF(X509)*,X509_STORE*,BIO*,BIO*,int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_verify");
537 K_PKCS7_get0_signers = (STACK_OF(X509) *(*)(PKCS7 *, STACK_OF(X509) *, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_get0_signers");
538 K_PKCS7_encrypt = (PKCS7* (*)(STACK_OF(X509) *, BIO *, EVP_CIPHER *, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_encrypt");
539 K_PKCS7_decrypt = (int (*)(PKCS7 *, EVP_PKEY *, X509 *, BIO *, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_decrypt");
540 K_PEM_X509_INFO_read = (STACK_OF(X509_INFO) *(*)(FILE*, STACK_OF(X509_INFO)*, pem_password_cb*,
void *)) GET_CRYPTOLIB_SYMBOL(
"PEM_X509_INFO_read");
541 K_ASN1_d2i_fp = (
char *(*)(
char *(*)(),
char *(*)(),FILE*,
unsigned char**)) GET_CRYPTOLIB_SYMBOL(
"ASN1_d2i_fp");
542 K_X509_new = (X509 *(*)()) GET_CRYPTOLIB_SYMBOL(
"X509_new");
543 K_X509_PURPOSE_get_count = (int (*)()) GET_CRYPTOLIB_SYMBOL(
"X509_PURPOSE_get_count");
544 K_X509_PURPOSE_get_id = (int (*)(X509_PURPOSE *)) GET_CRYPTOLIB_SYMBOL(
"X509_PURPOSE_get_id");
545 K_X509_check_purpose = (int (*)(X509*,int,int)) GET_CRYPTOLIB_SYMBOL(
"X509_check_purpose");
546 K_X509_PURPOSE_get0 = (X509_PURPOSE *(*)(
int)) GET_CRYPTOLIB_SYMBOL(
"X509_PURPOSE_get0");
547 K_EVP_PKEY_assign = (int (*)(EVP_PKEY*, int,
char*)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_assign");
548 K_X509_REQ_set_pubkey = (int (*)(X509_REQ*, EVP_PKEY*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_set_pubkey");
549 K_RSA_get0_key = (void (*)(
const RSA *r,
const BIGNUM **n,
const BIGNUM **e,
const BIGNUM **d)) GET_CRYPTOLIB_SYMBOL(
"RSA_get0_key");
550 K_RSA_generate_key = (RSA* (*)(
int,
unsigned long,
void (*)(int,int,
void *),
void *)) GET_CRYPTOLIB_SYMBOL(
"RSA_generate_key");
551 K_DSA_get0_pqg = (void (*)(
const DSA *d,
const BIGNUM **p,
const BIGNUM **q,
const BIGNUM **g)) GET_CRYPTOLIB_SYMBOL(
"DSA_get0_pqg");
552 K_DSA_get0_key = (void (*)(
const DSA *d,
const BIGNUM **pub_key,
const BIGNUM **priv_key)) GET_CRYPTOLIB_SYMBOL(
"DSA_get0_key");
553 K_i2d_X509_REQ_fp = (int (*)(FILE *, X509_REQ *)) GET_CRYPTOLIB_SYMBOL(
"i2d_X509_REQ_fp");
554 K_ERR_clear_error = (void (*)()) GET_CRYPTOLIB_SYMBOL(
"ERR_clear_error");
555 K_ERR_get_error = (
unsigned long (*)()) GET_CRYPTOLIB_SYMBOL(
"ERR_get_error");
556 K_ERR_print_errors_fp = (void (*)(FILE*)) GET_CRYPTOLIB_SYMBOL(
"ERR_print_errors_fp");
557 K_X509_get1_email = (STACK *(*)(X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_get1_email");
558 K_X509_email_free = (void (*)(STACK *sk)) GET_CRYPTOLIB_SYMBOL(
"X509_email_free");
559 K_EVP_des_ede3_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_des_ede3_cbc");
560 K_EVP_des_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_des_cbc");
561 K_EVP_rc2_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_rc2_cbc");
562 K_EVP_rc2_64_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_rc2_64_cbc");
563 K_EVP_rc2_40_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_rc2_40_cbc");
564 K_i2d_PrivateKey_fp = (int (*)(FILE*,EVP_PKEY*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PrivateKey_fp");
565 K_i2d_PKCS8PrivateKey_fp = (int (*)(FILE*, EVP_PKEY*,
const EVP_CIPHER*,
char*, int, pem_password_cb*,
void*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS8PrivateKey_fp");
566 K_RSA_free = (void (*)(RSA*)) GET_CRYPTOLIB_SYMBOL(
"RSA_free");
567 K_EVP_bf_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_bf_cbc");
568 K_X509_REQ_sign = (int (*)(X509_REQ*, EVP_PKEY*,
const EVP_MD*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_sign");
569 K_X509_NAME_add_entry_by_txt = (int (*)(X509_NAME*,
char*, int,
unsigned char*, int, int, int)) GET_CRYPTOLIB_SYMBOL(
"X509_NAME_add_entry_by_txt");
570 K_X509_NAME_new = (X509_NAME *(*)()) GET_CRYPTOLIB_SYMBOL(
"X509_NAME_new");
571 K_X509_REQ_set_subject_name = (int (*)(X509_REQ*,X509_NAME*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_set_subject_name");
572 K_ASN1_STRING_data = (
unsigned char *(*)(ASN1_STRING*)) GET_CRYPTOLIB_SYMBOL(
"ASN1_STRING_data");
573 K_ASN1_STRING_length = (int (*)(ASN1_STRING*)) GET_CRYPTOLIB_SYMBOL(
"ASN1_STRING_length");
574 K_X509_CRL_get0_lastUpdate = (
const ASN1_TIME* (*)(
const X509_CRL *crl)) GET_CRYPTOLIB_SYMBOL(
"X509_CRL_get0_lastUpdate");
575 K_X509_CRL_get0_nextUpdate = (
const ASN1_TIME* (*)(
const X509_CRL *crl)) GET_CRYPTOLIB_SYMBOL(
"X509_CRL_get0_nextUpdate");
576 K_X509_STORE_CTX_get_current_cert = (X509* (*)(X509_STORE_CTX *ctx)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_get_current_cert");
577 K_X509_STORE_CTX_get_error = (int (*)(X509_STORE_CTX *ctx)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_get_error");
578 K_X509_STORE_CTX_get_error_depth = (int (*)(X509_STORE_CTX *ctx)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_get_error_depth");
579 K_X509_STORE_CTX_set_error = (void (*)(X509_STORE_CTX *ctx,
int s)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_set_error");
580 K_X509_STORE_set_verify_cb = (void (*)(X509_STORE *ctx,
581 X509_STORE_CTX_verify_cb verify_cb)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_set_verify_cb");
582 K_X509_STORE_get0_objects = (STACK_OF(X509_OBJECT)* (*)(X509_STORE *v)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_get0_objects");
583 K_X509_OBJECT_get_type = (X509_LOOKUP_TYPE (*)(
const X509_OBJECT *a)) GET_CRYPTOLIB_SYMBOL(
"X509_OBJECT_get_type");
584 K_X509_OBJECT_get0_X509 = (X509* (*)(
const X509_OBJECT *a)) GET_CRYPTOLIB_SYMBOL(
"X509_OBJECT_get0_X509");
585 K_X509_getm_notAfter = (ASN1_TIME* (*)(
const X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_getm_notAfter");
586 K_X509_getm_notBefore = (ASN1_TIME* (*)(
const X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_getm_notBefore");
592 TQString libname = findMostRecentLib(
"/usr/lib",
"ssl");
593 if (!libname.isNull())
594 _sslLib = ll->globalLibrary(libname.latin1());
597 for (TQStringList::Iterator it = libpaths.begin();
598 it != libpaths.end();
600 for (TQStringList::Iterator shit = libnamess.begin();
601 shit != libnamess.end();
604 if (!alib.isEmpty() && !alib.endsWith(
"/"))
607 TQString tmpStr(alib.latin1());
608 tmpStr.replace(TQRegExp(
"\\(.*\\)"),
"");
609 if (!access(tmpStr.latin1(), R_OK))
610 _sslLib = ll->globalLibrary(alib.latin1());
620 K_SSL_connect = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_connect");
621 K_SSL_accept = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_accept");
622 K_SSL_read = (int (*)(SSL *,
void *, int)) GET_SSLLIB_SYMBOL(
"SSL_read");
623 K_SSL_write = (int (*)(SSL *,
const void *, int))
624 GET_SSLLIB_SYMBOL(
"SSL_write");
625 K_SSL_new = (SSL* (*)(SSL_CTX *)) GET_SSLLIB_SYMBOL(
"SSL_new");
626 K_SSL_free = (void (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_free");
627 K_SSL_shutdown = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_shutdown");
628 K_SSL_CTX_new = (SSL_CTX* (*)(SSL_METHOD*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_new");
629 K_SSL_CTX_free = (void (*)(SSL_CTX*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_free");
630 K_SSL_set_fd = (int (*)(SSL *, int)) GET_SSLLIB_SYMBOL(
"SSL_set_fd");
631 K_SSL_pending = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_pending");
632 K_SSL_CTX_set_cipher_list = (int (*)(SSL_CTX *,
const char *))
633 GET_SSLLIB_SYMBOL(
"SSL_CTX_set_cipher_list");
634 K_SSL_CTX_set_verify = (void (*)(SSL_CTX*, int, int (*)(int, X509_STORE_CTX*))) GET_SSLLIB_SYMBOL(
"SSL_CTX_set_verify");
635 K_SSL_use_certificate = (int (*)(SSL*, X509*))
636 GET_SSLLIB_SYMBOL(
"SSL_CTX_use_certificate");
637 K_SSL_get_current_cipher = (SSL_CIPHER *(*)(SSL *))
638 GET_SSLLIB_SYMBOL(
"SSL_get_current_cipher");
639 K_SSL_set_options = (long (*)(SSL *ssl,
long options)) GET_SSLLIB_SYMBOL(
"SSL_set_options");
640 K_SSL_session_reused = (int (*)(SSL *ssl)) GET_SSLLIB_SYMBOL(
"SSL_session_reused");
641 K_SSL_ctrl = (long (*)(SSL * ,int, long,
void *))
642 GET_SSLLIB_SYMBOL(
"SSL_ctrl");
643 K_TLSv1_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"TLSv1_client_method");
644 K_SSLv2_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"SSLv2_client_method");
645 K_SSLv3_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"SSLv3_client_method");
646 K_TLS_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"TLS_client_method");
647 if (!K_TLS_client_method) K_TLS_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"SSLv23_client_method");
648 K_SSL_get_peer_certificate = (X509 *(*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_get1_peer_certificate");
649 if (!K_SSL_get_peer_certificate) K_SSL_get_peer_certificate = (X509 *(*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_get_peer_certificate");
650 K_SSL_CIPHER_get_bits = (int (*)(SSL_CIPHER *,
int *)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_get_bits");
651 K_SSL_CIPHER_get_version = (
char * (*)(SSL_CIPHER *)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_get_version");
652 K_SSL_CIPHER_get_name = (
const char * (*)(SSL_CIPHER *)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_get_name");
653 K_SSL_CIPHER_description = (
char * (*)(SSL_CIPHER *,
char *,
int)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_description");
654 K_SSL_CTX_use_PrivateKey = (int (*)(SSL_CTX*, EVP_PKEY*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_use_PrivateKey");
655 K_SSL_CTX_use_certificate = (int (*)(SSL_CTX*, X509*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_use_certificate");
656 K_SSL_get_error = (int (*)(SSL*, int)) GET_SSLLIB_SYMBOL(
"SSL_get_error");
657 K_SSL_get_peer_cert_chain = (STACK_OF(X509)* (*)(SSL*)) GET_SSLLIB_SYMBOL(
"SSL_get_peer_cert_chain");
658 K_SSL_load_client_CA_file = (STACK_OF(X509_NAME)* (*)(
const char *)) GET_SSLLIB_SYMBOL(
"SSL_load_client_CA_file");
659 K_SSL_peek = (int (*)(SSL*,
void*,int)) GET_SSLLIB_SYMBOL(
"SSL_peek");
660 K_SSL_get1_session = (SSL_SESSION* (*)(SSL*)) GET_SSLLIB_SYMBOL(
"SSL_get1_session");
661 K_SSL_SESSION_free = (void (*)(SSL_SESSION*)) GET_SSLLIB_SYMBOL(
"SSL_SESSION_free");
662 K_SSL_set_session = (int (*)(SSL*,SSL_SESSION*)) GET_SSLLIB_SYMBOL(
"SSL_set_session");
663 K_d2i_SSL_SESSION = (SSL_SESSION* (*)(SSL_SESSION**,
unsigned char**,
long)) GET_SSLLIB_SYMBOL(
"d2i_SSL_SESSION");
664 K_i2d_SSL_SESSION = (int (*)(SSL_SESSION*,
unsigned char**)) GET_SSLLIB_SYMBOL(
"i2d_SSL_SESSION");
665 K_SSL_get_ciphers = (STACK_OF(SSL_CIPHER) *(*)(
const SSL*)) GET_SSLLIB_SYMBOL(
"SSL_get_ciphers");
671 x = GET_SSLLIB_SYMBOL(
"OPENSSL_init_ssl");
675 ((int (*)(
unsigned long long,
void*))x)(0, NULL);
676 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_init_crypto");
677 if (x) ((int (*)(
unsigned long long,
void*))x)(OPENSSL_INIT_ADD_ALL_CIPHERS
678 | OPENSSL_INIT_ADD_ALL_DIGESTS
679 | OPENSSL_INIT_LOAD_CONFIG,
685 x = GET_SSLLIB_SYMBOL(
"SSL_library_init");
687 if (x) ((int (*)())x)();
688 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_algorithms");
690 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_algorithms");
694 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_algorithms_conf");
696 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_algorithms_conf");
700 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_algorithms_noconf");
702 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_algorithms_noconf");
707 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_ciphers");
709 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_ciphers");
710 if (x) ((void (*)())x)();
711 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_digests");
713 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_digests");
714 if (x) ((void (*)())x)();
723 static KStaticDeleter<KOpenSSLProxy> medProxy;
727 KOpenSSLProxy::~KOpenSSLProxy() {
732 _cryptoLib->unload();
734 medProxy.setObject(0);
759 int KOpenSSLProxy::SSL_connect(SSL *ssl) {
760 if (K_SSL_connect)
return (K_SSL_connect)(ssl);
761 kdWarning() <<
"SSL_connect not defined!" << endl;
766 int KOpenSSLProxy::SSL_accept(SSL *ssl) {
767 if (K_SSL_accept)
return (K_SSL_accept)(ssl);
768 kdWarning() <<
"SSL_accept not defined!" << endl;
773 int KOpenSSLProxy::SSL_read(SSL *ssl,
void *buf,
int num) {
774 if (K_SSL_read)
return (K_SSL_read)(ssl, buf, num);
775 kdWarning() <<
"SSL_read not defined!" << endl;
780 int KOpenSSLProxy::SSL_write(SSL *ssl,
const void *buf,
int num) {
781 if (K_SSL_write)
return (K_SSL_write)(ssl, buf, num);
782 kdWarning() <<
"SSL_write not defined!" << endl;
787 SSL *KOpenSSLProxy::SSL_new(SSL_CTX *ctx) {
788 if (K_SSL_new)
return (K_SSL_new)(ctx);
789 kdWarning() <<
"SSL_new not defined!" << endl;
794 void KOpenSSLProxy::SSL_free(SSL *ssl) {
795 if (K_SSL_free) (K_SSL_free)(ssl);
796 else kdWarning() <<
"SSL_free not defined!" << endl;
800 int KOpenSSLProxy::SSL_shutdown(SSL *ssl) {
801 if (K_SSL_shutdown)
return (K_SSL_shutdown)(ssl);
802 kdWarning() <<
"SSL_shutdown not defined!" << endl;
807 SSL_CTX *KOpenSSLProxy::SSL_CTX_new(SSL_METHOD *method) {
808 if (K_SSL_CTX_new)
return (K_SSL_CTX_new)(method);
809 kdWarning() <<
"SSL_CTX_new not defined!" << endl;
814 void KOpenSSLProxy::SSL_CTX_free(SSL_CTX *ctx) {
815 if (K_SSL_CTX_free) (K_SSL_CTX_free)(ctx);
816 else kdWarning() <<
"SSL_CTX_free not defined!" << endl;
820 int KOpenSSLProxy::SSL_set_fd(SSL *ssl,
int fd) {
821 if (K_SSL_set_fd)
return (K_SSL_set_fd)(ssl, fd);
822 kdWarning() <<
"SSL_sed_fd not defined!" << endl;
827 int KOpenSSLProxy::SSL_pending(SSL *ssl) {
828 if (K_SSL_pending)
return (K_SSL_pending)(ssl);
829 kdWarning() <<
"SSL_pending not defined!" << endl;
834 int KOpenSSLProxy::SSL_CTX_set_cipher_list(SSL_CTX *ctx,
const char *str) {
835 if (K_SSL_CTX_set_cipher_list)
return (K_SSL_CTX_set_cipher_list)(ctx, str);
836 kdWarning() <<
"SSL_CTX_set_cipher_list not defined!" << endl;
841 void KOpenSSLProxy::SSL_CTX_set_verify(SSL_CTX *ctx,
int mode,
842 int (*verify_callback)(
int, X509_STORE_CTX *)) {
843 if (K_SSL_CTX_set_verify) (K_SSL_CTX_set_verify)(ctx, mode, verify_callback);
844 else kdWarning() <<
"SSL_CTX_set_verify not defined!" << endl;
848 int KOpenSSLProxy::SSL_use_certificate(SSL *ssl, X509 *x) {
849 if (K_SSL_use_certificate)
return (K_SSL_use_certificate)(ssl, x);
850 kdWarning() <<
"SSL_use_certificate not defined!" << endl;
855 SSL_CIPHER *KOpenSSLProxy::SSL_get_current_cipher(SSL *ssl) {
856 if (K_SSL_get_current_cipher)
return (K_SSL_get_current_cipher)(ssl);
857 kdWarning() <<
"SSL_get_current_cipher not defined!" << endl;
862 long KOpenSSLProxy::_SSL_set_options(SSL *ssl,
long options) {
863 if (K_SSL_set_options)
return (K_SSL_set_options)(ssl, options);
864 #if OPENSSL_VERSION_NUMBER < 0x10100000L
865 return this->SSL_set_options(ssl, options);
867 kdWarning() <<
"SSL_set_options not defined!" << endl;
872 int KOpenSSLProxy::_SSL_session_reused(SSL *ssl) {
873 if (K_SSL_session_reused)
return (K_SSL_session_reused)(ssl);
874 #if OPENSSL_VERSION_NUMBER < 0x10100000L
875 return this->SSL_session_reused(ssl);
877 kdWarning() <<
"SSL_session_reused not defined!" << endl;
882 long KOpenSSLProxy::SSL_ctrl(SSL *ssl,
int cmd,
long larg,
void *parg) {
883 if (K_SSL_ctrl)
return (K_SSL_ctrl)(ssl, cmd, larg, parg);
884 kdWarning() <<
"SSL_ctrl not defined!" << endl;
889 int KOpenSSLProxy::RAND_egd(
const char *path) {
890 if (K_RAND_egd)
return (K_RAND_egd)(path);
891 kdWarning() <<
"RAND_egd not defined!" << endl;
896 SSL_METHOD *KOpenSSLProxy::TLSv1_client_method() {
897 if (K_TLSv1_client_method)
return (K_TLSv1_client_method)();
898 kdWarning() <<
"TLSv1_client_method not defined!" << endl;
903 SSL_METHOD *KOpenSSLProxy::SSLv2_client_method() {
904 if (K_SSLv2_client_method)
return (K_SSLv2_client_method)();
905 kdWarning() <<
"SSLv2_client_method not defined!" << endl;
910 SSL_METHOD *KOpenSSLProxy::SSLv3_client_method() {
911 if (K_SSLv3_client_method)
return (K_SSLv3_client_method)();
912 kdWarning() <<
"SSLv3_client_method not defined!" << endl;
917 SSL_METHOD *KOpenSSLProxy::TLS_client_method() {
918 if (K_TLS_client_method)
return (K_TLS_client_method)();
919 kdWarning() <<
"TLS_client_method not defined!" << endl;
924 X509 *KOpenSSLProxy::SSL_get_peer_certificate(SSL *s) {
925 if (K_SSL_get_peer_certificate)
return (K_SSL_get_peer_certificate)(s);
926 kdWarning() <<
"SSL_get_peer_certificate not defined!" << endl;
931 int KOpenSSLProxy::SSL_CIPHER_get_bits(SSL_CIPHER *c,
int *alg_bits) {
932 if (K_SSL_CIPHER_get_bits)
return (K_SSL_CIPHER_get_bits)(c, alg_bits);
933 kdWarning() <<
"SSL_CIPHER_get_bits not defined!" << endl;
938 char * KOpenSSLProxy::SSL_CIPHER_get_version(SSL_CIPHER *c) {
939 if (K_SSL_CIPHER_get_version)
return (K_SSL_CIPHER_get_version)(c);
940 kdWarning() <<
"SSL_CIPHER_get_version not defined!" << endl;
945 const char * KOpenSSLProxy::SSL_CIPHER_get_name(SSL_CIPHER *c) {
946 if (K_SSL_CIPHER_get_name)
return (K_SSL_CIPHER_get_name)(c);
947 kdWarning() <<
"SSL_CIPHER_get_name not defined!" << endl;
952 char * KOpenSSLProxy::SSL_CIPHER_description(SSL_CIPHER *c,
char *buf,
int size) {
953 if (K_SSL_CIPHER_description)
return (K_SSL_CIPHER_description)(c,buf,size);
954 kdWarning() <<
"SSL_CIPHER_description not defined!" << endl;
959 X509 * KOpenSSLProxy::d2i_X509(X509 **a,
unsigned char **pp,
long length) {
960 if (K_d2i_X509)
return (K_d2i_X509)(a,pp,length);
961 kdWarning() <<
"d2i_X509 not defined!" << endl;
966 X509_CRL * KOpenSSLProxy::d2i_X509_CRL(X509_CRL **a,
unsigned char **pp,
long length) {
967 if (K_d2i_X509_CRL)
return (K_d2i_X509_CRL)(a,pp,length);
968 kdWarning() <<
"d2i_X509_CRL not defined!" << endl;
973 int KOpenSSLProxy::i2d_X509(X509 *a,
unsigned char **pp) {
974 if (K_i2d_X509)
return (K_i2d_X509)(a,pp);
975 kdWarning() <<
"i2d_X509 not defined!" << endl;
980 int KOpenSSLProxy::X509_cmp(X509 *a, X509 *b) {
981 if (K_X509_cmp)
return (K_X509_cmp)(a,b);
982 kdWarning() <<
"X509_cmp not defined!" << endl;
987 int KOpenSSLProxy::X509_subject_name_cmp(
const X509 *a,
const X509 *b) {
988 if (K_X509_subject_name_cmp)
return (K_X509_subject_name_cmp)(a, b);
989 kdWarning() <<
"X509_subject_name_cmp not defined!" << endl;
994 X509_STORE *KOpenSSLProxy::X509_STORE_new(
void) {
995 if (K_X509_STORE_new)
return (K_X509_STORE_new)();
996 kdWarning() <<
"X509_STORE_new not defined!" << endl;
1001 void KOpenSSLProxy::X509_STORE_free(X509_STORE *v) {
1002 if (K_X509_STORE_free) (K_X509_STORE_free)(v);
1003 else kdWarning() <<
"X509_STORE_free not defined!" << endl;
1007 X509_STORE_CTX *KOpenSSLProxy::X509_STORE_CTX_new(
void) {
1008 if (K_X509_STORE_CTX_new)
return (K_X509_STORE_CTX_new)();
1009 kdWarning() <<
"X509_STORE_CTX_new not defined!" << endl;
1014 void KOpenSSLProxy::X509_STORE_CTX_free(X509_STORE_CTX *ctx) {
1015 if (K_X509_STORE_CTX_free) (K_X509_STORE_CTX_free)(ctx);
1016 else kdWarning() <<
"X509_STORE_CTX_free not defined!" << endl;
1020 int KOpenSSLProxy::X509_verify_cert(X509_STORE_CTX *ctx) {
1021 if (K_X509_verify_cert)
return (K_X509_verify_cert)(ctx);
1022 kdWarning() <<
"X509_verify_cert not defined!" << endl;
1027 void KOpenSSLProxy::X509_free(X509 *a) {
1028 if (K_X509_free) (K_X509_free)(a);
1029 else kdWarning() <<
"X509_free not defined!" << endl;
1033 void KOpenSSLProxy::X509_CRL_free(X509_CRL *a) {
1034 if (K_X509_CRL_free) (K_X509_CRL_free)(a);
1035 else kdWarning() <<
"X509_CRL_free not defined!" << endl;
1039 char *KOpenSSLProxy::X509_NAME_oneline(X509_NAME *a,
char *buf,
int size) {
1040 if (K_X509_NAME_oneline)
return (K_X509_NAME_oneline)(a,buf,size);
1041 kdWarning() <<
"X509_NAME_online not defined!" << endl;
1046 X509_NAME *KOpenSSLProxy::X509_get_subject_name(X509 *a) {
1047 if (K_X509_get_subject_name)
return (K_X509_get_subject_name)(a);
1048 kdWarning() <<
"X509_get_subject not defined!" << endl;
1053 X509_NAME *KOpenSSLProxy::X509_get_issuer_name(X509 *a) {
1054 if (K_X509_get_issuer_name)
return (K_X509_get_issuer_name)(a);
1055 kdWarning() <<
"X509_get_issuer not defined!" << endl;
1060 X509_LOOKUP *KOpenSSLProxy::X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m) {
1061 if (K_X509_STORE_add_lookup)
return (K_X509_STORE_add_lookup)(v,m);
1062 kdWarning() <<
"X509_STORE_add_lookup not defined!" << endl;
1067 X509_LOOKUP_METHOD *KOpenSSLProxy::X509_LOOKUP_file(
void) {
1068 if (K_X509_LOOKUP_file)
return (K_X509_LOOKUP_file)();
1069 kdWarning() <<
"X509_LOOKUP_file not defined!" << endl;
1074 void KOpenSSLProxy::X509_LOOKUP_free(X509_LOOKUP *x) {
1075 if (K_X509_LOOKUP_free) (K_X509_LOOKUP_free)(x);
1076 else kdWarning() <<
"X509_LOOKUP_free not defined!" << endl;
1080 int KOpenSSLProxy::X509_LOOKUP_ctrl(X509_LOOKUP *ctx,
int cmd,
const char *argc,
long argl,
char **ret) {
1081 if (K_X509_LOOKUP_ctrl)
return (K_X509_LOOKUP_ctrl)(ctx,cmd,argc,argl,ret);
1082 kdWarning() <<
"X509_LOOKUP_ctrl not defined!" << endl;
1087 void KOpenSSLProxy::X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, STACK_OF(X509) *chain) {
1088 if (K_X509_STORE_CTX_init) (K_X509_STORE_CTX_init)(ctx,store,x509,chain);
1089 else kdWarning() <<
"X509_STORE_CTX_init not defined!" << endl;
1093 void KOpenSSLProxy::CRYPTO_free(
void *x) {
1094 if (K_CRYPTO_free) (K_CRYPTO_free)(x);
1095 else kdWarning() <<
"CRYPTO_free not defined!" << endl;
1099 X509 *KOpenSSLProxy::X509_dup(X509 *x509) {
1100 if (K_X509_dup)
return (K_X509_dup)(x509);
1101 kdWarning() <<
"X509_dup not defined!" << endl;
1106 void KOpenSSLProxy::X509_get0_signature(
const ASN1_BIT_STRING **psig,
1107 const X509_ALGOR **palg,
const X509 *x) {
1108 if (K_X509_get0_signature) {
1109 (X509_get0_signature)(psig, palg, x);
1112 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1114 if (psig) *psig = x->signature;
1115 if (palg) *palg = x->sig_alg;
1118 kdWarning() <<
"X509_get0_signature not defined!" << endl;
1122 BIO *KOpenSSLProxy::BIO_new(BIO_METHOD *type) {
1123 if (K_BIO_new)
return (K_BIO_new)(type);
1124 kdWarning() <<
"BIO_new not defined!" << endl;
1129 BIO_METHOD *KOpenSSLProxy::BIO_s_mem(
void) {
1130 if (K_BIO_s_mem)
return (K_BIO_s_mem)();
1131 kdWarning() <<
"BIO_s_mem not defined!" << endl;
1136 BIO *KOpenSSLProxy::BIO_new_fp(FILE *stream,
int close_flag) {
1137 if (K_BIO_new_fp)
return (K_BIO_new_fp)(stream, close_flag);
1138 kdWarning() <<
"BIO_new_fp not defined!" << endl;
1143 BIO *KOpenSSLProxy::BIO_new_mem_buf(
void *buf,
int len) {
1144 if (K_BIO_new_mem_buf)
return (K_BIO_new_mem_buf)(buf,len);
1145 kdWarning() <<
"BIO_new_mem_buf not defined!" << endl;
1150 int KOpenSSLProxy::BIO_free(BIO *a) {
1151 if (K_BIO_free)
return (K_BIO_free)(a);
1152 kdWarning() <<
"BIO_free not defined!" << endl;
1157 long KOpenSSLProxy::BIO_ctrl(BIO *bp,
int cmd,
long larg,
void *parg) {
1158 if (K_BIO_ctrl)
return (K_BIO_ctrl)(bp,cmd,larg,parg);
1159 kdWarning() <<
"BIO_ctrl not defined!" << endl;
1164 int KOpenSSLProxy::BIO_write(BIO *b,
const void *data,
int len) {
1165 if (K_BIO_write)
return (K_BIO_write)(b, data, len);
1166 kdWarning() <<
"BIO_write not defined!" << endl;
1171 void *KOpenSSLProxy::BIO_get_data(BIO *a) {
1172 if (K_BIO_get_data)
return (K_BIO_get_data)(a);
1173 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1176 kdWarning() <<
"BIO_get_data not defined!" << endl;
1181 int KOpenSSLProxy::PEM_write_bio_X509(BIO *bp, X509 *x) {
1182 if (K_PEM_ASN1_write_bio)
return (K_PEM_ASN1_write_bio) ((int (*)())K_i2d_X509, PEM_STRING_X509, bp, (
char *)x, 0L, 0L, 0, 0L, 0L);
1183 kdWarning() <<
"PEM_write_bio_X509 not defined!" << endl;
1187 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
1188 int KOpenSSLProxy::ASN1_i2d_fp(FILE *out,
unsigned char *x) {
1189 if (K_ASN1_item_i2d_fp && K_NETSCAPE_X509_it)
1190 return (K_ASN1_item_i2d_fp)(K_NETSCAPE_X509_it, out, x);
1191 kdWarning() <<
"ANS1_i2d_fp not defined!" << endl;
1195 ASN1_METHOD *KOpenSSLProxy::X509_asn1_meth(
void) {
1196 if (K_X509_asn1_meth)
return (K_X509_asn1_meth)();
1197 kdWarning() <<
"X509_ans1_meth not defined!" << endl;
1202 int KOpenSSLProxy::ASN1_i2d_fp(FILE *out,
unsigned char *x) {
1203 if (K_ASN1_i2d_fp && K_i2d_ASN1_HEADER)
1204 return (K_ASN1_i2d_fp)((int (*)())K_i2d_ASN1_HEADER, out, x);
1205 kdWarning() <<
"ANS1_i2d_fp not defined!" << endl;
1210 int KOpenSSLProxy::X509_print(FILE *fp, X509 *x) {
1211 if (K_X509_print_fp)
return (K_X509_print_fp)(fp, x);
1212 kdWarning() <<
"X509_print not defined!" << endl;
1217 PKCS12 *KOpenSSLProxy::d2i_PKCS12_fp(FILE *fp, PKCS12 **p12) {
1218 if (K_d2i_PKCS12_fp)
return (K_d2i_PKCS12_fp)(fp, p12);
1219 kdWarning() <<
"d2i_PKCS12_fp not defined!" << endl;
1224 int KOpenSSLProxy::PKCS12_newpass(PKCS12 *p12,
char *oldpass,
char *newpass) {
1225 if (K_PKCS12_newpass)
return (K_PKCS12_newpass)(p12, oldpass, newpass);
1226 kdWarning() <<
"PKCS12_newpass not defined!" << endl;
1231 int KOpenSSLProxy::i2d_PKCS12(PKCS12 *p12,
unsigned char **p) {
1232 if (K_i2d_PKCS12)
return (K_i2d_PKCS12)(p12, p);
1233 kdWarning() <<
"i2d_PKCS12 not defined!" << endl;
1238 int KOpenSSLProxy::i2d_PKCS12_fp(FILE *fp, PKCS12 *p12) {
1239 if (K_i2d_PKCS12_fp)
return (K_i2d_PKCS12_fp)(fp, p12);
1240 kdWarning() <<
"i2d_PKCS12_fp not defined!" << endl;
1245 PKCS12 *KOpenSSLProxy::PKCS12_new(
void) {
1246 if (K_PKCS12_new)
return (K_PKCS12_new)();
1247 kdWarning() <<
"PKCS12_new not defined!" << endl;
1252 void KOpenSSLProxy::PKCS12_free(PKCS12 *a) {
1253 if (K_PKCS12_free) (K_PKCS12_free)(a);
1254 else kdWarning() <<
"PKCS12_free not defined!" << endl;
1258 int KOpenSSLProxy::PKCS12_parse(PKCS12 *p12,
const char *pass, EVP_PKEY **pkey,
1259 X509 **cert, STACK_OF(X509) **ca) {
1260 if (K_PKCS12_parse)
return (K_PKCS12_parse) (p12, pass, pkey, cert, ca);
1261 kdWarning() <<
"PKCS12_parse not defined!" << endl;
1266 void KOpenSSLProxy::EVP_PKEY_free(EVP_PKEY *x) {
1267 if (K_EVP_PKEY_free) (K_EVP_PKEY_free)(x);
1268 else kdWarning() <<
"EVP_PKEY_free not defined!" << endl;
1272 EVP_PKEY* KOpenSSLProxy::EVP_PKEY_new() {
1273 if (K_EVP_PKEY_new)
return (K_EVP_PKEY_new)();
1274 kdWarning() <<
"EVP_PKEY_new not defined!" << endl;
1279 int KOpenSSLProxy::EVP_PKEY_base_id(
const EVP_PKEY *pkey) {
1280 if (K_EVP_PKEY_base_id)
return (K_EVP_PKEY_base_id)(pkey);
1281 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1284 kdWarning() <<
"EVP_PKEY_base_id not defined!" << endl;
1289 RSA* KOpenSSLProxy::EVP_PKEY_get0_RSA(EVP_PKEY *pkey) {
1290 if (K_EVP_PKEY_get0_RSA)
return (K_EVP_PKEY_get0_RSA)(pkey);
1291 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1292 return pkey->pkey.rsa;
1294 kdWarning() <<
"EVP_PKEY_get0_RSA not defined!" << endl;
1299 DSA* KOpenSSLProxy::EVP_PKEY_get0_DSA(EVP_PKEY *pkey) {
1300 if (K_EVP_PKEY_get0_DSA)
return (K_EVP_PKEY_get0_DSA)(pkey);
1301 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1302 return pkey->pkey.dsa;
1304 kdWarning() <<
"EVP_PKEY_get0_DSA not defined!" << endl;
1309 void KOpenSSLProxy::X509_REQ_free(X509_REQ *x) {
1310 if (K_X509_REQ_free) (K_X509_REQ_free)(x);
1311 else kdWarning() <<
"X509_REQ_free not defined!" << endl;
1315 X509_REQ* KOpenSSLProxy::X509_REQ_new() {
1316 if (K_X509_REQ_new)
return (K_X509_REQ_new)();
1317 kdWarning() <<
"X509_REQ_new not defined!" << endl;
1322 int KOpenSSLProxy::SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey) {
1323 if (K_SSL_CTX_use_PrivateKey)
return (K_SSL_CTX_use_PrivateKey)(ctx,pkey);
1324 kdWarning() <<
"SSL_CTX_use_PrivateKey not defined!" << endl;
1329 int KOpenSSLProxy::SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x) {
1330 if (K_SSL_CTX_use_certificate)
return (K_SSL_CTX_use_certificate)(ctx,x);
1331 kdWarning() <<
"SSL_CTX_use_certificate not defined!" << endl;
1336 int KOpenSSLProxy::SSL_get_error(SSL *ssl,
int rc) {
1337 if (K_SSL_get_error)
return (K_SSL_get_error)(ssl,rc);
1338 kdWarning() <<
"SSL_get_error not defined!" << endl;
1343 STACK_OF(X509) *KOpenSSLProxy::SSL_get_peer_cert_chain(SSL *s) {
1344 if (K_SSL_get_peer_cert_chain)
return (K_SSL_get_peer_cert_chain)(s);
1345 kdWarning() <<
"SSL_get_peer_cert_chain not defined!" << endl;
1350 void KOpenSSLProxy::OPENSSL_sk_free(STACK *s) {
1351 if (K_sk_free) (K_sk_free)(s);
1352 else kdWarning() <<
"OPENSSL_sk_free not defined!" << endl;
1356 int KOpenSSLProxy::OPENSSL_sk_num(STACK *s) {
1357 if (K_sk_num)
return (K_sk_num)(s);
1358 kdWarning() <<
"OPENSSL_sk_num not defined!" << endl;
1363 char *KOpenSSLProxy::OPENSSL_sk_pop(STACK *s) {
1364 if (K_sk_pop)
return (K_sk_pop)(s);
1365 kdWarning() <<
"OPENSSL_sk_pop not defined!" << endl;
1370 char *KOpenSSLProxy::OPENSSL_sk_value(STACK *s,
int n) {
1371 if (K_sk_value)
return (K_sk_value)(s, n);
1372 kdWarning() <<
"OPENSSL_sk_value not defined!" << endl;
1377 void KOpenSSLProxy::X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *v, STACK_OF(X509)* x) {
1378 if (K_X509_STORE_CTX_set0_untrusted) (K_X509_STORE_CTX_set0_untrusted)(v,x);
1379 else kdWarning() <<
"X509_STORE_CTX_set0_untrusted not defined!" << endl;
1382 void KOpenSSLProxy::X509_STORE_CTX_set_purpose(X509_STORE_CTX *v,
int purpose) {
1383 if (K_X509_STORE_CTX_set_purpose) (K_X509_STORE_CTX_set_purpose)(v,purpose);
1384 else kdWarning() <<
"X509_STORE_CTX_set_purpose not defined!" << endl;
1388 STACK* KOpenSSLProxy::OPENSSL_sk_dup(
const STACK *s) {
1389 if (K_sk_dup)
return (K_sk_dup)(s);
1390 kdWarning() <<
"OPENSSL_sk_dup not defined!" << endl;
1395 STACK* KOpenSSLProxy::OPENSSL_sk_new(
int (*cmp)()) {
1396 if (K_sk_new)
return (K_sk_new)(cmp);
1397 kdWarning() <<
"OPENSSL_sk_new not defined!" << endl;
1402 int KOpenSSLProxy::OPENSSL_sk_push(STACK* s,
char* d) {
1403 if (K_sk_push)
return (K_sk_push)(s,d);
1404 kdWarning() <<
"OPENSSL_sk_push not defined!" << endl;
1409 char *KOpenSSLProxy::i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, ASN1_INTEGER *aint) {
1410 if (K_i2s_ASN1_INTEGER)
return (K_i2s_ASN1_INTEGER)(meth, aint);
1411 kdWarning() <<
"i2s_ANS1_INTEGER not defined!" << endl;
1416 ASN1_INTEGER *KOpenSSLProxy::X509_get_serialNumber(X509 *x) {
1417 if (K_X509_get_serialNumber)
return (K_X509_get_serialNumber)(x);
1418 kdWarning() <<
"X509_get_serialNumber not defined!" << endl;
1423 EVP_PKEY *KOpenSSLProxy::X509_get_pubkey(X509 *x) {
1424 if (K_X509_get_pubkey)
return (K_X509_get_pubkey)(x);
1425 kdWarning() <<
"X59_get_pubkey not defined!" << endl;
1430 int KOpenSSLProxy::i2d_PublicKey(EVP_PKEY *a,
unsigned char **pp) {
1431 if (K_i2d_PublicKey)
return (K_i2d_PublicKey)(a,pp);
1432 kdWarning() <<
"i2d_PublicKey not defined!" << endl;
1437 int KOpenSSLProxy::X509_check_private_key(X509 *x, EVP_PKEY *p) {
1438 if (K_X509_check_private_key)
return (K_X509_check_private_key)(x,p);
1439 kdWarning() <<
"X509_check_private_key not defined!" << endl;
1444 char *KOpenSSLProxy::BN_bn2hex(
const BIGNUM *a) {
1445 if (K_BN_bn2hex)
return (K_BN_bn2hex)(a);
1446 kdWarning() <<
"BN_bn2hex not defined!" << endl;
1451 int KOpenSSLProxy::X509_digest(
const X509 *x,
const EVP_MD *t,
unsigned char *md,
unsigned int *len) {
1452 if (K_X509_digest)
return (K_X509_digest)(x, t, md, len);
1453 kdWarning() <<
"X509_digest not defined!" << endl;
1458 EVP_MD *KOpenSSLProxy::EVP_md5() {
1459 if (K_EVP_md5)
return (K_EVP_md5)();
1460 kdWarning() <<
"EVP_md5 not defined!" << endl;
1465 void KOpenSSLProxy::ASN1_INTEGER_free(ASN1_INTEGER *a) {
1466 if (K_ASN1_INTEGER_free) (K_ASN1_INTEGER_free)(a);
1467 else kdWarning() <<
"ANS1_INTEGER_free not defined!" << endl;
1471 int KOpenSSLProxy::OBJ_obj2nid(ASN1_OBJECT *o) {
1472 if (K_OBJ_obj2nid)
return (K_OBJ_obj2nid)(o);
1473 kdWarning() <<
"OBJ_obj2nid not defined!" << endl;
1478 const char * KOpenSSLProxy::OBJ_nid2ln(
int n) {
1479 if (K_OBJ_nid2ln)
return (K_OBJ_nid2ln)(n);
1480 kdWarning() <<
"OBJ_nid2ln not defined!" << endl;
1485 int KOpenSSLProxy::X509_get_ext_count(X509 *x) {
1486 if (K_X509_get_ext_count)
return (K_X509_get_ext_count)(x);
1487 kdWarning() <<
"X509_get_ext_count not defined!" << endl;
1492 int KOpenSSLProxy::X509_get_ext_by_NID(X509 *x,
int nid,
int lastpos) {
1493 if (K_X509_get_ext_by_NID)
return (K_X509_get_ext_by_NID)(x,nid,lastpos);
1494 kdWarning() <<
"X509_get_ext_by_NID not defined!" << endl;
1499 int KOpenSSLProxy::X509_get_ext_by_OBJ(X509 *x,ASN1_OBJECT *obj,
int lastpos) {
1500 if (K_X509_get_ext_by_OBJ)
return (K_X509_get_ext_by_OBJ)(x,obj,lastpos);
1501 kdWarning() <<
"X509_get_ext_by_OBJ not defined!" << endl;
1506 X509_EXTENSION *KOpenSSLProxy::X509_get_ext(X509 *x,
int loc) {
1507 if (K_X509_get_ext)
return (K_X509_get_ext)(x,loc);
1508 kdWarning() <<
"X509_get_ext not defined!" << endl;
1513 X509_EXTENSION *KOpenSSLProxy::X509_delete_ext(X509 *x,
int loc) {
1514 if (K_X509_delete_ext)
return (K_X509_delete_ext)(x,loc);
1515 kdWarning() <<
"X509_delete_ext not defined!" << endl;
1520 int KOpenSSLProxy::X509_add_ext(X509 *x, X509_EXTENSION *ex,
int loc) {
1521 if (K_X509_add_ext)
return (K_X509_add_ext)(x,ex,loc);
1522 kdWarning() <<
"X509_add_ext not defined!" << endl;
1527 void *KOpenSSLProxy::X509_get_ext_d2i(X509 *x,
int nid,
int *crit,
int *idx) {
1528 if (K_X509_get_ext_d2i)
return (K_X509_get_ext_d2i)(x,nid,crit,idx);
1529 kdWarning() <<
"X509_get_ext_d2i not defined!" << endl;
1534 char *KOpenSSLProxy::i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *ia5) {
1535 if (K_i2s_ASN1_OCTET_STRING)
return (K_i2s_ASN1_OCTET_STRING)(method,ia5);
1536 kdWarning() <<
"i2s_ANS1_OCTET_STRING not defined!" << endl;
1541 int KOpenSSLProxy::ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a,
int n) {
1542 if (K_ASN1_BIT_STRING_get_bit)
return (K_ASN1_BIT_STRING_get_bit)(a,n);
1543 kdWarning() <<
"ANS1_BIT_STRING_get_bit not defined!" << endl;
1548 PKCS7 *KOpenSSLProxy::PKCS7_new(
void) {
1549 if (K_PKCS7_new)
return (K_PKCS7_new)();
1550 kdWarning() <<
"PKCS7_new not defined!" << endl;
1555 void KOpenSSLProxy::PKCS7_free(PKCS7 *a) {
1556 if (K_PKCS7_free) (K_PKCS7_free)(a);
1557 else kdWarning() <<
"PKCS7_free not defined!" << endl;
1561 void KOpenSSLProxy::PKCS7_content_free(PKCS7 *a) {
1562 if (K_PKCS7_content_free) (K_PKCS7_content_free)(a);
1563 else kdWarning() <<
"PKCS7_content_free not defined!" << endl;
1567 int KOpenSSLProxy::i2d_PKCS7(PKCS7 *a,
unsigned char **pp) {
1568 if (K_i2d_PKCS7)
return (K_i2d_PKCS7)(a,pp);
1569 kdWarning() <<
"i2d_PKCS7 not defined!" << endl;
1574 PKCS7 *KOpenSSLProxy::d2i_PKCS7(PKCS7 **a,
unsigned char **pp,
long length) {
1575 if (K_d2i_PKCS7)
return (K_d2i_PKCS7)(a,pp,length);
1576 kdWarning() <<
"d2i_PKCS7 not defined!" << endl;
1581 int KOpenSSLProxy::i2d_PKCS7_fp(FILE *fp,PKCS7 *p7) {
1582 if (K_i2d_PKCS7_fp)
return (K_i2d_PKCS7_fp)(fp,p7);
1583 kdWarning() <<
"i2d_PKCS7_fd not defined!" << endl;
1588 PKCS7 *KOpenSSLProxy::d2i_PKCS7_fp(FILE *fp,PKCS7 **p7) {
1589 if (K_d2i_PKCS7_fp)
return (K_d2i_PKCS7_fp)(fp,p7);
1590 kdWarning() <<
"d2i_PKCS7_fp not defined!" << endl;
1595 int KOpenSSLProxy::i2d_PKCS7_bio(BIO *bp,PKCS7 *p7) {
1596 if (K_i2d_PKCS7_bio)
return (K_i2d_PKCS7_bio)(bp, p7);
1597 kdWarning() <<
"i2d_PKCS7_bio not defined!" << endl;
1602 PKCS7 *KOpenSSLProxy::d2i_PKCS7_bio(BIO *bp,PKCS7 **p7) {
1603 if (K_d2i_PKCS7_bio)
return (K_d2i_PKCS7_bio)(bp, p7);
1604 kdWarning() <<
"d2i_PKCS7_bio not defined!" << endl;
1609 PKCS7 *KOpenSSLProxy::PKCS7_dup(PKCS7 *p7) {
1610 if (K_PKCS7_dup)
return (K_PKCS7_dup)(p7);
1611 kdWarning() <<
"PKCS7_dup not defined!" << endl;
1616 PKCS7 *KOpenSSLProxy::PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
1617 BIO *data,
int flags) {
1618 if (K_PKCS7_sign)
return (K_PKCS7_sign)(signcert,pkey,certs,data,flags);
1619 kdWarning() <<
"PKCS7_sign not defined!" << endl;
1624 int KOpenSSLProxy::PKCS7_verify(PKCS7* p, STACK_OF(X509)* st, X509_STORE* s, BIO* in, BIO *out,
int flags) {
1625 if (K_PKCS7_verify)
return (K_PKCS7_verify)(p,st,s,in,out,flags);
1626 kdWarning() <<
"PKCS7_verify not defined!" << endl;
1631 STACK_OF(X509) *KOpenSSLProxy::PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs,
int flags) {
1632 if (K_PKCS7_get0_signers)
return (K_PKCS7_get0_signers)(p7,certs,flags);
1633 kdWarning() <<
"PKCS7_get0_signers not defined!" << endl;
1638 PKCS7 *KOpenSSLProxy::PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, EVP_CIPHER *cipher,
1640 if (K_PKCS7_encrypt)
return (K_PKCS7_encrypt)(certs,in,cipher,flags);
1641 kdWarning() <<
"PKCS7_encrypt not defined!" << endl;
1646 int KOpenSSLProxy::PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data,
int flags) {
1647 if (K_PKCS7_decrypt)
return (K_PKCS7_decrypt)(p7,pkey,cert,data,flags);
1648 kdWarning() <<
"PKCS7_decrypt not defined!" << endl;
1653 STACK_OF(X509_NAME) *KOpenSSLProxy::SSL_load_client_CA_file(
const char *file) {
1654 if (K_SSL_load_client_CA_file)
return (K_SSL_load_client_CA_file)(file);
1655 kdWarning() <<
"SSL_load_client_CA_file not defined!" << endl;
1660 STACK_OF(X509_INFO) *KOpenSSLProxy::PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb,
void *u) {
1661 if (K_PEM_X509_INFO_read)
return (K_PEM_X509_INFO_read)(fp,sk,cb,u);
1662 kdWarning() <<
"PEM_X509_INFO_read not defined!" << endl;
1667 X509 *KOpenSSLProxy::X509_d2i_fp(FILE *out, X509** buf) {
1668 if (K_ASN1_d2i_fp)
return reinterpret_cast<X509 *
>((K_ASN1_d2i_fp)(
reinterpret_cast<char *(*)()
>(K_X509_new),
reinterpret_cast<char *(*)()
>(K_d2i_X509), out,
reinterpret_cast<unsigned char **
>(buf)));
1669 kdWarning() <<
"X509_d2i_fp not defined!" << endl;
1674 int KOpenSSLProxy::SSL_peek(SSL *ssl,
void *buf,
int num) {
1675 if (K_SSL_peek)
return (K_SSL_peek)(ssl,buf,num);
1676 kdWarning() <<
"SSL_peek not defined!" << endl;
1681 const char *KOpenSSLProxy::RAND_file_name(
char *buf,
size_t num) {
1682 if (K_RAND_file_name)
return (K_RAND_file_name)(buf, num);
1683 kdWarning() <<
"RAND_file_name not defined!" << endl;
1688 int KOpenSSLProxy::RAND_load_file(
const char *filename,
long max_bytes) {
1689 if (K_RAND_load_file)
return (K_RAND_load_file)(filename, max_bytes);
1690 kdWarning() <<
"REND_load_file not defined!" << endl;
1695 int KOpenSSLProxy::RAND_write_file(
const char *filename) {
1696 if (K_RAND_write_file)
return (K_RAND_write_file)(filename);
1697 kdWarning() <<
"RAND_write_file not defined!" << endl;
1702 int KOpenSSLProxy::X509_PURPOSE_get_count() {
1703 if (K_X509_PURPOSE_get_count)
return (K_X509_PURPOSE_get_count)();
1704 kdWarning() <<
"X509_PURPOSE_get_count not defined!" << endl;
1709 int KOpenSSLProxy::X509_PURPOSE_get_id(X509_PURPOSE *p) {
1710 if (K_X509_PURPOSE_get_id)
return (K_X509_PURPOSE_get_id)(p);
1711 kdWarning() <<
"X509_PURPOSE_get_id not defined!" << endl;
1716 int KOpenSSLProxy::X509_check_purpose(X509 *x,
int id,
int ca) {
1717 if (K_X509_check_purpose)
return (K_X509_check_purpose)(x, id, ca);
1718 kdWarning() <<
"X509_check_purpose not defined!" << endl;
1723 X509_PURPOSE *KOpenSSLProxy::X509_PURPOSE_get0(
int idx) {
1724 if (K_X509_PURPOSE_get0)
return (K_X509_PURPOSE_get0)(idx);
1725 kdWarning() <<
"X509_PURPOSE_get0 not defined!" << endl;
1730 int KOpenSSLProxy::EVP_PKEY_assign(EVP_PKEY *pkey,
int type,
char *key) {
1731 if (K_EVP_PKEY_assign)
return (K_EVP_PKEY_assign)(pkey, type, key);
1732 kdWarning() <<
"EVP_PKEY_assign not defined!" << endl;
1737 int KOpenSSLProxy::X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey) {
1738 if (K_X509_REQ_set_pubkey)
return (K_X509_REQ_set_pubkey)(x, pkey);
1739 kdWarning() <<
"X509_REQ_set_pubkey not defined!" << endl;
1744 void KOpenSSLProxy::RSA_get0_key(
const RSA *r,
1745 const BIGNUM **n,
const BIGNUM **e,
const BIGNUM **d) {
1746 if (K_RSA_get0_key) {
1747 (K_RSA_get0_key)(r, n, e, d);
1750 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1757 kdWarning() <<
"REG_get0_key not defined!" << endl;
1761 RSA* KOpenSSLProxy::RSA_generate_key(
int bits,
unsigned long e,
void
1762 (*callback)(
int,
int,
void *),
void *cb_arg) {
1763 if (K_RSA_generate_key)
return (K_RSA_generate_key)(bits, e, callback, cb_arg);
1764 kdWarning() <<
"RSA_generate_key not defined!" << endl;
1769 void KOpenSSLProxy::DSA_get0_pqg(
const DSA *d,
1770 const BIGNUM **p,
const BIGNUM **q,
const BIGNUM **g) {
1771 if (K_DSA_get0_pqg) {
1772 (K_DSA_get0_pqg)(d, p, q, g);
1775 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1782 kdWarning() <<
"DSA_get0_pqg not defined!" << endl;
1786 void KOpenSSLProxy::DSA_get0_key(
const DSA *d,
1787 const BIGNUM **pub_key,
const BIGNUM **priv_key) {
1788 if (K_DSA_get0_key) {
1789 (K_DSA_get0_key)(d, pub_key, priv_key);
1792 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1794 if (pub_key) *pub_key = d->pub_key;
1795 if (priv_key) *priv_key = d->priv_key;
1798 kdWarning() <<
"DSA_get0_key not defined!" << endl;
1802 STACK *KOpenSSLProxy::X509_get1_email(X509 *x) {
1803 if (K_X509_get1_email)
return (K_X509_get1_email)(x);
1804 kdWarning() <<
"X509_get1_email not defined!" << endl;
1808 void KOpenSSLProxy::X509_email_free(STACK *sk) {
1809 if (K_X509_email_free) (K_X509_email_free)(sk);
1810 else kdWarning() <<
"X509_email_free not defined!" << endl;
1813 EVP_CIPHER *KOpenSSLProxy::EVP_des_ede3_cbc() {
1814 if (K_EVP_des_ede3_cbc)
return (K_EVP_des_ede3_cbc)();
1815 kdWarning() <<
"EVM_des_ede3_cbc not defined!" << endl;
1819 EVP_CIPHER *KOpenSSLProxy::EVP_des_cbc() {
1820 if (K_EVP_des_cbc)
return (K_EVP_des_cbc)();
1821 kdWarning() <<
"EVP_des_cbc not defined!" << endl;
1825 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_cbc() {
1826 if (K_EVP_rc2_cbc)
return (K_EVP_rc2_cbc)();
1827 kdWarning() <<
"EVP_rc2_cbc not defined!" << endl;
1831 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_64_cbc() {
1832 if (K_EVP_rc2_64_cbc)
return (K_EVP_rc2_64_cbc)();
1833 kdWarning() <<
"EVP_rc2_64_cbc not defined!" << endl;
1837 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_40_cbc() {
1838 if (K_EVP_rc2_40_cbc)
return (K_EVP_rc2_40_cbc)();
1839 kdWarning() <<
"EVP_rc2_40_cbc not defined!" << endl;
1843 int KOpenSSLProxy::i2d_X509_REQ_fp(FILE *fp, X509_REQ *x) {
1844 if (K_i2d_X509_REQ_fp)
return (K_i2d_X509_REQ_fp)(fp,x);
1845 kdWarning() <<
"i2d_X509_REQ_fp not defined!" << endl;
1850 void KOpenSSLProxy::ERR_clear_error() {
1851 if (K_ERR_clear_error) (K_ERR_clear_error)();
1852 else kdWarning() <<
"ERR_clear_error not defined!" << endl;
1856 unsigned long KOpenSSLProxy::ERR_get_error() {
1857 if (K_ERR_get_error)
return (K_ERR_get_error)();
1858 kdWarning() <<
"ERR_get_error not defined!" << endl;
1863 void KOpenSSLProxy::ERR_print_errors_fp(FILE* fp) {
1864 if (K_ERR_print_errors_fp) (K_ERR_print_errors_fp)(fp);
1865 else kdWarning() <<
"ERR_print_errors_fp not defined!" << endl;
1869 SSL_SESSION *KOpenSSLProxy::SSL_get1_session(SSL *ssl) {
1870 if (K_SSL_get1_session)
return (K_SSL_get1_session)(ssl);
1871 kdWarning() <<
"SSL_get1_session not defined!" << endl;
1876 void KOpenSSLProxy::SSL_SESSION_free(SSL_SESSION *session) {
1877 if (K_SSL_SESSION_free) (K_SSL_SESSION_free)(session);
1878 else kdWarning() <<
"SSL_SESSION_free not defined!" << endl;
1882 int KOpenSSLProxy::SSL_set_session(SSL *ssl, SSL_SESSION *session) {
1883 if (K_SSL_set_session)
return (K_SSL_set_session)(ssl, session);
1884 kdWarning() <<
"SSL_set_session not defined!" << endl;
1889 SSL_SESSION *KOpenSSLProxy::d2i_SSL_SESSION(SSL_SESSION **a,
unsigned char **pp,
long length) {
1890 if (K_d2i_SSL_SESSION)
return (K_d2i_SSL_SESSION)(a, pp, length);
1891 kdWarning() <<
"d2i_SSL_SESSION not defined!" << endl;
1896 int KOpenSSLProxy::i2d_SSL_SESSION(SSL_SESSION *in,
unsigned char **pp) {
1897 if (K_i2d_SSL_SESSION)
return (K_i2d_SSL_SESSION)(in, pp);
1898 kdWarning() <<
"i2d_SSL_SESSION not defined!" << endl;
1903 int KOpenSSLProxy::i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *p) {
1904 if (K_i2d_PrivateKey_fp)
return (K_i2d_PrivateKey_fp)(fp, p);
1905 kdWarning() <<
"i2d_PrivateKey not defined!" << endl;
1910 int KOpenSSLProxy::i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *p,
const EVP_CIPHER *c,
char *k,
int klen, pem_password_cb *cb,
void *u) {
1911 if (K_i2d_PKCS8PrivateKey_fp)
return (K_i2d_PKCS8PrivateKey_fp)(fp, p, c, k, klen, cb, u);
1912 kdWarning() <<
"i2d_PKCS8PrivateKey_fp not defined!" << endl;
1917 void KOpenSSLProxy::RSA_free(RSA *rsa) {
1918 if (K_RSA_free) (K_RSA_free)(rsa);
1919 else kdWarning() <<
"RSA_free not defined!" << endl;
1923 EVP_CIPHER *KOpenSSLProxy::EVP_bf_cbc() {
1924 if (K_EVP_bf_cbc)
return (K_EVP_bf_cbc)();
1925 kdWarning() <<
"EVP_bf_cbc not defined!" << endl;
1930 int KOpenSSLProxy::X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey,
const EVP_MD *md) {
1931 if (K_X509_REQ_sign)
return (K_X509_REQ_sign)(x, pkey, md);
1932 kdWarning() <<
"X509_REQ_sign not defined!" << endl;
1937 int KOpenSSLProxy::X509_NAME_add_entry_by_txt(X509_NAME *name,
char *field,
1938 int type,
unsigned char *bytes,
int len,
int loc,
int set) {
1939 if (K_X509_NAME_add_entry_by_txt)
return (K_X509_NAME_add_entry_by_txt)(name, field, type, bytes, len, loc, set);
1940 kdWarning() <<
"X509_NAME_add_entry not defined!" << endl;
1945 X509_NAME *KOpenSSLProxy::X509_NAME_new() {
1946 if (K_X509_NAME_new)
return (K_X509_NAME_new)();
1947 kdWarning() <<
"X509_NAME_new not defined!" << endl;
1952 int KOpenSSLProxy::X509_REQ_set_subject_name(X509_REQ *req,X509_NAME *name) {
1953 if (K_X509_REQ_set_subject_name)
return (K_X509_REQ_set_subject_name)(req, name);
1954 kdWarning() <<
"X509_REQ_set_subject_name not defined!" << endl;
1959 unsigned char *KOpenSSLProxy::ASN1_STRING_data(ASN1_STRING *x) {
1960 if (K_ASN1_STRING_data)
return (K_ASN1_STRING_data)(x);
1961 kdWarning() <<
"ASN1_STRING_data not defined!" << endl;
1965 int KOpenSSLProxy::ASN1_STRING_length(ASN1_STRING *x) {
1966 if (K_ASN1_STRING_length)
return (K_ASN1_STRING_length)(x);
1967 kdWarning() <<
"ASN1_STRING_length not defined!" << endl;
1971 STACK_OF(SSL_CIPHER) *KOpenSSLProxy::SSL_get_ciphers(
const SSL* ssl) {
1972 if (K_SSL_get_ciphers)
return (K_SSL_get_ciphers)(ssl);
1973 kdWarning() <<
"SSL_get_ciphers not defined!" << endl;
1977 const ASN1_TIME* KOpenSSLProxy::X509_CRL_get0_lastUpdate(
const X509_CRL *crl) {
1978 if (K_X509_CRL_get0_lastUpdate)
return (K_X509_CRL_get0_lastUpdate)(crl);
1979 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1980 return X509_CRL_get_lastUpdate(crl);
1982 kdWarning() <<
"X509_CRL_get_lastUpdate not defined!" << endl;
1986 const ASN1_TIME* KOpenSSLProxy::X509_CRL_get0_nextUpdate(
const X509_CRL *crl) {
1987 if (K_X509_CRL_get0_nextUpdate)
return (K_X509_CRL_get0_nextUpdate)(crl);
1988 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1989 return X509_CRL_get_nextUpdate(crl);
1991 kdWarning() <<
"X509_CRL_get_nextUpdate not defined!" << endl;
1995 X509* KOpenSSLProxy::X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx) {
1996 if (K_X509_STORE_CTX_get_current_cert)
return (K_X509_STORE_CTX_get_current_cert)(ctx);
1997 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1998 return ctx->current_cert;
2000 kdWarning() <<
"X509_STORE_CTX_get_current_cert not defined!" << endl;
2004 int KOpenSSLProxy::X509_STORE_CTX_get_error(X509_STORE_CTX *ctx) {
2005 if (K_X509_STORE_CTX_get_error)
return (K_X509_STORE_CTX_get_error)(ctx);
2006 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2009 kdWarning() <<
"X509k_STORE_CTX_get_error not defined!" << endl;
2013 int KOpenSSLProxy::X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx) {
2014 if (K_X509_STORE_CTX_get_error_depth)
return (K_X509_STORE_CTX_get_error_depth)(ctx);
2015 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2016 return ctx->error_depth;
2018 kdWarning() <<
"X509_STORE_CTX_get_error_depth not defined!" << endl;
2022 void KOpenSSLProxy::X509_STORE_CTX_set_error(X509_STORE_CTX *ctx,
int s) {
2023 if (K_X509_STORE_CTX_set_error) {
2024 (K_X509_STORE_CTX_set_error)(ctx, s);
2027 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2031 kdWarning() <<
"X509_STORE_CTX_set_error not defined!" << endl;
2034 void KOpenSSLProxy::X509_STORE_set_verify_cb(X509_STORE *ctx,
2035 X509_STORE_CTX_verify_cb verify_cb) {
2036 if (K_X509_STORE_set_verify_cb) {
2037 (K_X509_STORE_set_verify_cb)(ctx, verify_cb);
2040 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2041 X509_STORE_set_verify_cb_func(ctx, verify_cb);
2044 kdWarning() <<
"X590_STORE_set_verify_cb not defined!" << endl;
2047 STACK_OF(X509_OBJECT)* KOpenSSLProxy::X509_STORE_get0_objects(X509_STORE *v) {
2048 if (K_X509_STORE_get0_objects)
return (K_X509_STORE_get0_objects)(v);
2049 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2052 kdWarning() <<
"X509_STORE_get0_objects not defined!" << endl;
2056 X509_LOOKUP_TYPE KOpenSSLProxy::X509_OBJECT_get_type(
const X509_OBJECT *a) {
2057 if (K_X509_OBJECT_get_type)
return (K_X509_OBJECT_get_type)(a);
2058 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2061 kdWarning() <<
"X509_OBJECT_get_type not defined!" << endl;
2062 #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
2063 return X509_LU_NONE;
2069 X509* KOpenSSLProxy::X509_OBJECT_get0_X509(
const X509_OBJECT *a) {
2070 if (K_X509_OBJECT_get0_X509)
return (K_X509_OBJECT_get0_X509)(a);
2071 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
2072 return a->data.x509;
2074 kdWarning() <<
"X509_OBJECT_get0_X509 not defined!" << endl;
2079 ASN1_TIME* KOpenSSLProxy::X509_getm_notAfter(
const X509 *x) {
2080 if (K_X509_getm_notAfter)
return (K_X509_getm_notAfter)(x);
2081 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
2082 return X509_get_notAfter(x);
2084 kdWarning() <<
"X509_get_notAfter not defined!" << endl;
2088 ASN1_TIME* KOpenSSLProxy::X509_getm_notBefore(
const X509 *x) {
2089 if (K_X509_getm_notBefore)
return (K_X509_getm_notBefore)(x);
2090 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
2091 return X509_get_notBefore(x);
2093 kdWarning() <<
"X509_get_notBefore not defined!" << endl;
2098 STACK* KOpenSSLProxy::sk_dup(
const STACK *s) {
2099 return OPENSSL_sk_dup(s);
2102 void KOpenSSLProxy::sk_free(STACK *s) {
2106 STACK* KOpenSSLProxy::sk_new(
int (*cmp)()) {
2107 return OPENSSL_sk_new(cmp);
2110 int KOpenSSLProxy::sk_num(STACK *s) {
2111 return OPENSSL_sk_num(s);
2114 char* KOpenSSLProxy::sk_pop(STACK *s) {
2115 return OPENSSL_sk_pop(s);
2118 int KOpenSSLProxy::sk_push(STACK *s,
char *d) {
2119 return OPENSSL_sk_push(s, d);
2122 char* KOpenSSLProxy::sk_value(STACK *s,
int n) {
2123 return OPENSSL_sk_value(s, n);
2126 void KOpenSSLProxy::X509_STORE_CTX_set_chain(X509_STORE_CTX *v, STACK_OF(X509)* x) {
2127 X509_STORE_CTX_set0_untrusted(v, x);
2130 SSL_METHOD* KOpenSSLProxy::SSLv23_client_method() {
2131 return TLS_client_method();
Dynamically load and wrap OpenSSL.
void destroy()
Destroy the class and start over - don't use this unless you know what you are doing.
bool hasLibSSL() const
Return true of libssl was found and loaded.
bool hasLibCrypto() const
Return true of libcrypto was found and loaded.
static KOpenSSLProxy * self()
Return an instance of class KOpenSSLProxy * You cannot delete this object.