24 #include <openssl/opensslv.h>
29 #include <kstaticdeleter.h>
36 #define GET_CRYPTOLIB_SYMBOL(a) ((_cryptoLib->hasSymbol(a)) ? _cryptoLib->symbol(a) : NULL)
37 #define GET_SSLLIB_SYMBOL(a) ((_sslLib->hasSymbol(a)) ? _sslLib->symbol(a) : NULL)
40 #if !defined(OPENSSL_INIT_ADD_ALL_CIPHERS)
41 # define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L
42 # define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L
43 # define OPENSSL_INIT_LOAD_CONFIG 0x00000040L
48 static int (*K_SSL_connect) (SSL *) = 0L;
49 static int (*K_SSL_accept) (SSL *) = 0L;
50 static int (*K_SSL_read) (SSL *,
void *, int) = 0L;
51 static int (*K_SSL_write) (SSL *,
const void *, int) = 0L;
52 static SSL *(*K_SSL_new) (SSL_CTX *) = 0L;
53 static void (*K_SSL_free) (SSL *) = 0L;
54 static int (*K_SSL_shutdown) (SSL *) = 0L;
55 static SSL_CTX *(*K_SSL_CTX_new)(SSL_METHOD *) = 0L;
56 static void (*K_SSL_CTX_free) (SSL_CTX *) = 0L;
57 static int (*K_SSL_set_fd) (SSL *, int) = 0L;
58 static int (*K_SSL_pending) (SSL *) = 0L;
59 static int (*K_SSL_peek) (SSL *,
void *, int) = 0L;
60 static int (*K_SSL_CTX_set_cipher_list)(SSL_CTX *,
const char *) = 0L;
61 static void (*K_SSL_CTX_set_verify)(SSL_CTX *, int,
62 int (*)(int, X509_STORE_CTX *)) = 0L;
63 static int (*K_SSL_use_certificate)(SSL *, X509 *) = 0L;
64 static SSL_CIPHER *(*K_SSL_get_current_cipher)(SSL *) = 0L;
65 static long (*K_SSL_set_options)(SSL *ssl,
long options) = 0L;
66 static int (*K_SSL_session_reused)(SSL *ssl) = 0L;
67 static long (*K_SSL_ctrl) (SSL *,int, long,
void *) = 0L;
68 static int (*K_RAND_egd) (
const char *) = 0L;
69 static const char* (*K_RAND_file_name) (
char *, size_t) = 0L;
70 static int (*K_RAND_load_file) (
const char *, long) = 0L;
71 static int (*K_RAND_write_file) (
const char *) = 0L;
72 static SSL_METHOD * (*K_TLSv1_client_method) () = 0L;
73 static SSL_METHOD * (*K_SSLv2_client_method) () = 0L;
74 static SSL_METHOD * (*K_SSLv3_client_method) () = 0L;
75 static SSL_METHOD * (*K_TLS_client_method) () = 0L;
76 static X509 * (*K_SSL_get_peer_certificate) (SSL *) = 0L;
77 static int (*K_SSL_CIPHER_get_bits) (SSL_CIPHER *,
int *) = 0L;
78 static char * (*K_SSL_CIPHER_get_version) (SSL_CIPHER *) = 0L;
79 static const char * (*K_SSL_CIPHER_get_name) (SSL_CIPHER *) = 0L;
80 static char * (*K_SSL_CIPHER_description) (SSL_CIPHER *,
char *, int) = 0L;
81 static X509 * (*K_d2i_X509) (X509 **,
unsigned char **,long) = 0L;
82 static X509_CRL * (*K_d2i_X509_CRL) (X509_CRL **,
unsigned char **,long) = 0L;
83 static int (*K_i2d_X509) (X509 *,
unsigned char **) = 0L;
84 static int (*K_X509_cmp) (X509 *, X509 *) = 0L;
85 static int (*K_X509_subject_name_cmp) (
const X509 *,
const X509 *) = 0L;
86 static void (*K_X509_STORE_CTX_free) (X509_STORE_CTX *) = 0L;
87 static int (*K_X509_verify_cert) (X509_STORE_CTX *) = 0L;
88 static X509_STORE_CTX *(*K_X509_STORE_CTX_new) (void) = 0L;
89 static void (*K_X509_STORE_free) (X509_STORE *) = 0L;
90 static X509_STORE *(*K_X509_STORE_new) (void) = 0L;
91 static void (*K_X509_free) (X509 *) = 0L;
92 static void (*K_X509_CRL_free) (X509_CRL *) = 0L;
93 static char *(*K_X509_NAME_oneline) (X509_NAME *,
char *,int) = 0L;
94 static X509_NAME *(*K_X509_get_subject_name) (X509 *) = 0L;
95 static X509_NAME *(*K_X509_get_issuer_name) (X509 *) = 0L;
96 static X509_LOOKUP *(*K_X509_STORE_add_lookup) (X509_STORE *, X509_LOOKUP_METHOD *) = 0L;
97 static X509_LOOKUP_METHOD *(*K_X509_LOOKUP_file)(void) = 0L;
98 static void (*K_X509_LOOKUP_free)(X509_LOOKUP *) = 0L;
99 static int (*K_X509_LOOKUP_ctrl)(X509_LOOKUP *, int,
const char *, long,
char **) = 0L;
100 static void (*K_X509_STORE_CTX_init)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *) = 0L;
101 static void (*K_CRYPTO_free) (
void *) = 0L;
102 static X509* (*K_X509_dup) (X509 *) = 0L;
103 static void (*K_X509_get0_signature)(
const ASN1_BIT_STRING **psig,
104 const X509_ALGOR **palg,
const X509 *x) = 0L;
105 static BIO_METHOD *(*K_BIO_s_mem) (void) = 0L;
106 static BIO* (*K_BIO_new) (BIO_METHOD *) = 0L;
107 static BIO* (*K_BIO_new_fp) (FILE *, int) = 0L;
108 static BIO* (*K_BIO_new_mem_buf) (
void *, int) = 0L;
109 static int (*K_BIO_free) (BIO *) = 0L;
110 static long (*K_BIO_ctrl) (BIO *,int,long,
void *) = 0L;
111 static int (*K_BIO_write) (BIO *b,
const void *data,
int len) = 0L;
112 static void* (*K_BIO_get_data) (BIO *a) = 0L;
113 static int (*K_PEM_ASN1_write_bio) (int (*)(),
const char *,BIO *,
char *,
114 const EVP_CIPHER *,
unsigned char *,
int ,
115 pem_password_cb *,
void *) = 0L;
116 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
117 static int (*K_ASN1_item_i2d_fp)(ASN1_ITEM *,FILE *,
unsigned char *) = 0L;
118 static ASN1_ITEM *K_NETSCAPE_X509_it = 0L;
120 static ASN1_METHOD* (*K_X509_asn1_meth) (void) = 0L;
121 static int (*K_ASN1_i2d_fp)(int (*)(),FILE *,
unsigned char *) = 0L;
122 static int (*K_i2d_ASN1_HEADER)(ASN1_HEADER *,
unsigned char **) = 0L;
124 static int (*K_X509_print_fp) (FILE *, X509*) = 0L;
125 static int (*K_i2d_PKCS12) (PKCS12*,
unsigned char**) = 0L;
126 static int (*K_i2d_PKCS12_fp) (FILE *, PKCS12*) = 0L;
127 static int (*K_PKCS12_newpass) (PKCS12*,
char*,
char*) = 0L;
128 static PKCS12* (*K_d2i_PKCS12_fp) (FILE*, PKCS12**) = 0L;
129 static PKCS12* (*K_PKCS12_new) (void) = 0L;
130 static void (*K_PKCS12_free) (PKCS12 *) = 0L;
131 static int (*K_PKCS12_parse) (PKCS12*,
const char *, EVP_PKEY**,
132 X509**, STACK_OF(X509)**) = 0L;
133 static void (*K_EVP_PKEY_free) (EVP_PKEY *) = 0L;
134 static EVP_PKEY* (*K_EVP_PKEY_new) () = 0L;
135 static int (*K_EVP_PKEY_base_id)(
const EVP_PKEY *pkey) = 0L;
136 static RSA* (*K_EVP_PKEY_get0_RSA)(EVP_PKEY *pkey) = 0L;
137 static DSA* (*K_EVP_PKEY_get0_DSA)(EVP_PKEY *pkey) = 0L;
138 static void (*K_X509_REQ_free) (X509_REQ *) = 0L;
139 static X509_REQ* (*K_X509_REQ_new) () = 0L;
140 static int (*K_SSL_CTX_use_PrivateKey) (SSL_CTX*, EVP_PKEY*) = 0L;
141 static int (*K_SSL_CTX_use_certificate) (SSL_CTX*, X509*) = 0L;
142 static int (*K_SSL_get_error) (SSL*, int) = 0L;
143 static STACK_OF(X509)* (*K_SSL_get_peer_cert_chain) (SSL*) = 0L;
144 static void (*K_X509_STORE_CTX_set0_untrusted) (X509_STORE_CTX *, STACK_OF(X509)*) = 0L;
145 static void (*K_X509_STORE_CTX_set_purpose) (X509_STORE_CTX *, int) = 0L;
146 static void (*K_sk_free) (STACK*) = 0L;
147 static int (*K_sk_num) (STACK*) = 0L;
148 static char* (*K_sk_pop) (STACK*) = 0L;
149 static char* (*K_sk_value) (STACK*, int) = 0L;
150 static STACK* (*K_sk_new) (int (*)()) = 0L;
151 static int (*K_sk_push) (STACK*,
char*) = 0L;
152 static STACK* (*K_sk_dup) (
const STACK *) = 0L;
153 static char * (*K_i2s_ASN1_INTEGER) (X509V3_EXT_METHOD *, ASN1_INTEGER *) =0L;
154 static ASN1_INTEGER * (*K_X509_get_serialNumber) (X509 *) = 0L;
155 static EVP_PKEY *(*K_X509_get_pubkey)(X509 *) = 0L;
156 static int (*K_i2d_PublicKey)(EVP_PKEY *,
unsigned char **) = 0L;
157 static int (*K_X509_check_private_key)(X509 *, EVP_PKEY *) = 0L;
158 static char * (*K_BN_bn2hex)(
const BIGNUM *) = 0L;
159 static int (*K_X509_digest)(
const X509 *,
const EVP_MD *,
unsigned char *,
unsigned int *) = 0L;
160 static EVP_MD* (*K_EVP_md5)() = 0L;
161 static void (*K_ASN1_INTEGER_free)(ASN1_INTEGER *) = 0L;
162 static int (*K_OBJ_obj2nid)(ASN1_OBJECT *) = 0L;
163 static const char * (*K_OBJ_nid2ln)(int) = 0L;
164 static int (*K_X509_get_ext_count)(X509*) = 0L;
165 static int (*K_X509_get_ext_by_NID)(X509*, int, int) = 0L;
166 static int (*K_X509_get_ext_by_OBJ)(X509*,ASN1_OBJECT*,int) = 0L;
167 static X509_EXTENSION *(*K_X509_get_ext)(X509*,
int loc) = 0L;
168 static X509_EXTENSION *(*K_X509_delete_ext)(X509*, int) = 0L;
169 static int (*K_X509_add_ext)(X509*, X509_EXTENSION*, int) = 0L;
170 static void *(*K_X509_get_ext_d2i)(X509*, int,
int*,
int*) = 0L;
171 static char *(*K_i2s_ASN1_OCTET_STRING)(X509V3_EXT_METHOD*, ASN1_OCTET_STRING*) = 0L;
172 static int (*K_ASN1_BIT_STRING_get_bit)(ASN1_BIT_STRING*, int) = 0L;
173 static PKCS7 *(*K_PKCS7_new)() = 0L;
174 static void (*K_PKCS7_free)(PKCS7*) = 0L;
175 static void (*K_PKCS7_content_free)(PKCS7*) = 0L;
176 static int (*K_i2d_PKCS7)(PKCS7*,
unsigned char**) = 0L;
177 static PKCS7 *(*K_d2i_PKCS7)(PKCS7**,
unsigned char**,long) = 0L;
178 static int (*K_i2d_PKCS7_fp)(FILE*,PKCS7*) = 0L;
179 static PKCS7* (*K_d2i_PKCS7_fp)(FILE*,PKCS7**) = 0L;
180 static int (*K_i2d_PKCS7_bio)(BIO *bp,PKCS7 *p7) = 0L;
181 static PKCS7 *(*K_d2i_PKCS7_bio)(BIO *bp,PKCS7 **p7) = 0L;
182 static PKCS7* (*K_PKCS7_dup)(PKCS7*) = 0L;
183 static STACK_OF(X509_NAME) *(*K_SSL_load_client_CA_file)(
const char*) = 0L;
184 static STACK_OF(X509_INFO) *(*K_PEM_X509_INFO_read)(FILE*, STACK_OF(X509_INFO)*, pem_password_cb*,
void*) = 0L;
185 static char *(*K_ASN1_d2i_fp)(
char *(*)(),
char *(*)(),FILE*,
unsigned char**) = 0L;
186 static X509 *(*K_X509_new)() = 0L;
187 static int (*K_X509_PURPOSE_get_count)() = 0L;
188 static int (*K_X509_PURPOSE_get_id)(X509_PURPOSE *) = 0L;
189 static int (*K_X509_check_purpose)(X509*,int,int) = 0L;
190 static X509_PURPOSE* (*K_X509_PURPOSE_get0)(int) = 0L;
191 static int (*K_EVP_PKEY_assign)(EVP_PKEY*, int,
char*) = 0L;
192 static int (*K_X509_REQ_set_pubkey)(X509_REQ*, EVP_PKEY*) = 0L;
193 static void (*K_RSA_get0_key)(
const RSA *r,
const BIGNUM **n,
const BIGNUM **e,
const BIGNUM **d) = 0L;
194 static RSA *(*K_RSA_generate_key)(int,
unsigned long, void (*)(int,int,
void *),
void *) = 0L;
195 static void (*K_DSA_get0_pqg)(
const DSA *d,
const BIGNUM **p,
const BIGNUM **q,
const BIGNUM **g) = 0L;
196 static void (*K_DSA_get0_key)(
const DSA *d,
const BIGNUM **pub_key,
const BIGNUM **priv_key) = 0L;
197 static int (*K_i2d_X509_REQ_fp)(FILE*, X509_REQ*) = 0L;
198 static void (*K_ERR_clear_error)() = 0L;
199 static unsigned long (*K_ERR_get_error)() = 0L;
200 static void (*K_ERR_print_errors_fp)(FILE*) = 0L;
201 static PKCS7 *(*K_PKCS7_sign)(X509*, EVP_PKEY*, STACK_OF(X509)*, BIO*, int) = 0L;
202 static int (*K_PKCS7_verify)(PKCS7*,STACK_OF(X509)*,X509_STORE*,BIO*,BIO*,int) = 0L;
203 static STACK_OF(X509) *(*K_PKCS7_get0_signers)(PKCS7 *, STACK_OF(X509) *, int) = 0L;
204 static PKCS7 *(*K_PKCS7_encrypt)(STACK_OF(X509) *, BIO *, EVP_CIPHER *, int) = 0L;
205 static int (*K_PKCS7_decrypt)(PKCS7 *, EVP_PKEY *, X509 *, BIO *, int) = 0L;
206 static SSL_SESSION* (*K_SSL_get1_session)(SSL*) = 0L;
207 static void (*K_SSL_SESSION_free)(SSL_SESSION*) = 0L;
208 static int (*K_SSL_set_session)(SSL*,SSL_SESSION*) = 0L;
209 static SSL_SESSION* (*K_d2i_SSL_SESSION)(SSL_SESSION**,
unsigned char**, long) = 0L;
210 static int (*K_i2d_SSL_SESSION)(SSL_SESSION*,
unsigned char**) = 0L;
211 static STACK *(*K_X509_get1_email)(X509 *x) = 0L;
212 static void (*K_X509_email_free)(STACK *sk) = 0L;
213 static EVP_CIPHER *(*K_EVP_des_ede3_cbc)() = 0L;
214 static EVP_CIPHER *(*K_EVP_des_cbc)() = 0L;
215 static EVP_CIPHER *(*K_EVP_rc2_cbc)() = 0L;
216 static EVP_CIPHER *(*K_EVP_rc2_64_cbc)() = 0L;
217 static EVP_CIPHER *(*K_EVP_rc2_40_cbc)() = 0L;
218 static int (*K_i2d_PrivateKey_fp)(FILE*,EVP_PKEY*) = 0L;
219 static int (*K_i2d_PKCS8PrivateKey_fp)(FILE*, EVP_PKEY*,
const EVP_CIPHER*,
char*, int, pem_password_cb*,
void*) = 0L;
220 static void (*K_RSA_free)(RSA*) = 0L;
221 static EVP_CIPHER *(*K_EVP_bf_cbc)() = 0L;
222 static int (*K_X509_REQ_sign)(X509_REQ*, EVP_PKEY*,
const EVP_MD*) = 0L;
223 static int (*K_X509_NAME_add_entry_by_txt)(X509_NAME*,
char*, int,
unsigned char*, int, int, int) = 0L;
224 static X509_NAME *(*K_X509_NAME_new)() = 0L;
225 static int (*K_X509_REQ_set_subject_name)(X509_REQ*,X509_NAME*) = 0L;
226 static unsigned char *(*K_ASN1_STRING_data)(ASN1_STRING*) = 0L;
227 static int (*K_ASN1_STRING_length)(ASN1_STRING*) = 0L;
228 static STACK_OF(SSL_CIPHER) *(*K_SSL_get_ciphers)(
const SSL *ssl) = 0L;
229 static const ASN1_TIME* (*K_X509_CRL_get0_lastUpdate)(
const X509_CRL *crl) = 0L;
230 static const ASN1_TIME* (*K_X509_CRL_get0_nextUpdate)(
const X509_CRL *crl) = 0L;
231 static X509* (*K_X509_STORE_CTX_get_current_cert)(X509_STORE_CTX *ctx) = 0L;
232 static int (*K_X509_STORE_CTX_get_error)(X509_STORE_CTX *ctx) = 0L;
233 static int (*K_X509_STORE_CTX_get_error_depth)(X509_STORE_CTX *ctx) = 0L;
234 static void (*K_X509_STORE_CTX_set_error)(X509_STORE_CTX *ctx,
int s) = 0L;
235 static void (*K_X509_STORE_set_verify_cb)(X509_STORE *ctx,
236 X509_STORE_CTX_verify_cb verify_cb) = 0L;
237 static STACK_OF(X509_OBJECT)* (*K_X509_STORE_get0_objects)(X509_STORE *v) = 0L;
238 static X509_LOOKUP_TYPE (*K_X509_OBJECT_get_type)(
const X509_OBJECT *a) = 0L;
239 static X509* (*K_X509_OBJECT_get0_X509)(
const X509_OBJECT *a) = 0L;
240 static ASN1_TIME* (*K_X509_getm_notAfter)(
const X509 *x) = 0L;
241 static ASN1_TIME* (*K_X509_getm_notBefore)(
const X509 *x) = 0L;
247 return _sslLib != 0L;
252 return _cryptoLib != 0L;
263 #include <tqstring.h>
264 #include <tqstringlist.h>
266 static TQString findMostRecentLib(TQString dir, TQString name)
269 TQString filter =
"lib"+name+
".so.*";
270 TQDir d(dir, filter);
273 TQStringList l = d.entryList();
280 uint s = filter.length()-1;
281 for (TQStringList::Iterator it = l.begin(); it != l.end(); ++it) {
282 TQString numberpart = (*it).mid(s);
283 uint endmaj = numberpart.find(
'.');
287 int maj = numberpart.left(endmaj).toInt(&ok);
290 int min = numberpart.mid(endmaj+1).toInt(&ok);
293 if (maj > bestmaj || (maj == bestmaj && min > bestmin)) {
307 KOpenSSLProxy::KOpenSSLProxy() {
308 KLibLoader *ll = KLibLoader::self();
310 TQStringList libpaths, libnamesc, libnamess;
316 cfg =
new KConfig(
"cryptodefaults",
false,
false);
317 cfg->setGroup(
"OpenSSL");
318 TQString upath = cfg->readPathEntry(
"Path");
319 if (!upath.isEmpty())
326 TQString libname = findMostRecentLib(
"/usr/" SYSTEM_LIBDIR,
"crypto");
327 if (!libname.isNull())
328 _cryptoLib = ll->globalLibrary(libname.latin1());
330 #elif defined(__CYGWIN__)
331 libpaths <<
"/usr/bin/"
333 <<
"/usr/local/openssl/bin"
334 <<
"/opt/openssl/bin"
335 <<
"/opt/trinity/bin"
338 libnamess <<
"cygssl-0.9.7.dll"
343 libnamesc <<
"cygcrypto.dll"
349 <<
"/opt/freeware/lib/"
351 <<
"/usr/" SYSTEM_LIBDIR
"/"
352 <<
"/usr/ssl/" SYSTEM_LIBDIR
"/"
353 <<
"/usr/local/" SYSTEM_LIBDIR
"/"
354 <<
"/usr/local/openssl/" SYSTEM_LIBDIR
"/"
355 <<
"/usr/local/ssl/" SYSTEM_LIBDIR
"/"
356 <<
"/opt/openssl/" SYSTEM_LIBDIR
"/"
357 <<
"/" SYSTEM_LIBDIR
"/"
365 <<
"libssl.a(libssl.so.0)"
366 #elif defined(__APPLE__)
368 <<
"libssl.0.9.dylib"
370 #ifdef SHLIB_VERSION_NUMBER
371 <<
"libssl.so." SHLIB_VERSION_NUMBER
382 <<
"libcrypto.a(libcrypto.so.0)"
383 #elif defined(__APPLE__)
385 <<
"libcrypto.0.9.dylib"
387 #ifdef SHLIB_VERSION_NUMBER
388 <<
"libcrypto.so." SHLIB_VERSION_NUMBER
396 for (TQStringList::Iterator it = libpaths.begin();
397 it != libpaths.end();
399 for (TQStringList::Iterator shit = libnamesc.begin();
400 shit != libnamesc.end();
403 if (!alib.isEmpty() && !alib.endsWith(
"/"))
406 TQString tmpStr(alib.latin1());
407 tmpStr.replace(TQRegExp(
"\\(.*\\)"),
"");
408 if (!access(tmpStr.latin1(), R_OK))
409 _cryptoLib = ll->globalLibrary(alib.latin1());
410 if (_cryptoLib)
break;
412 if (_cryptoLib)
break;
417 K_X509_free = (void (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_free");
418 K_X509_CRL_free = (void (*) (X509_CRL *)) GET_CRYPTOLIB_SYMBOL(
"X509_CRL_free");
419 K_RAND_egd = (int (*)(
const char *)) GET_CRYPTOLIB_SYMBOL(
"RAND_egd");
420 K_RAND_load_file = (int (*)(
const char *, long)) GET_CRYPTOLIB_SYMBOL(
"RAND_load_file");
421 K_RAND_file_name = (
const char* (*)(
char *,
size_t)) GET_CRYPTOLIB_SYMBOL(
"RAND_file_name");
422 K_RAND_write_file = (int (*)(
const char *)) GET_CRYPTOLIB_SYMBOL(
"RAND_write_file");
423 K_CRYPTO_free = (void (*) (
void *)) GET_CRYPTOLIB_SYMBOL(
"CRYPTO_free");
424 K_d2i_X509 = (X509 * (*)(X509 **,
unsigned char **,
long)) GET_CRYPTOLIB_SYMBOL(
"d2i_X509");
425 K_d2i_X509_CRL = (X509_CRL * (*)(X509_CRL **,
unsigned char **,
long)) GET_CRYPTOLIB_SYMBOL(
"d2i_X509_CRL");
426 K_i2d_X509 = (int (*)(X509 *,
unsigned char **)) GET_CRYPTOLIB_SYMBOL(
"i2d_X509");
427 K_X509_cmp = (int (*)(X509 *, X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_cmp");
428 K_X509_subject_name_cmp = (int (*)(
const X509 *,
const X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_subject_name_cmp");
429 K_X509_STORE_CTX_new = (X509_STORE_CTX * (*) (
void)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_new");
430 K_X509_STORE_CTX_free = (void (*) (X509_STORE_CTX *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_free");
431 K_X509_verify_cert = (int (*) (X509_STORE_CTX *)) GET_CRYPTOLIB_SYMBOL(
"X509_verify_cert");
432 K_X509_STORE_new = (X509_STORE * (*) (
void)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_new");
433 K_X509_STORE_free = (void (*) (X509_STORE *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_free");
434 K_X509_NAME_oneline = (
char * (*) (X509_NAME *,
char *,
int)) GET_CRYPTOLIB_SYMBOL(
"X509_NAME_oneline");
435 K_X509_get_subject_name = (X509_NAME * (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_subject_name");
436 K_X509_get_issuer_name = (X509_NAME * (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_issuer_name");
437 K_X509_STORE_add_lookup = (X509_LOOKUP *(*) (X509_STORE *, X509_LOOKUP_METHOD *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_add_lookup");
438 K_X509_LOOKUP_file = (X509_LOOKUP_METHOD *(*)(
void)) GET_CRYPTOLIB_SYMBOL(
"X509_LOOKUP_file");
439 K_X509_LOOKUP_free = (void (*)(X509_LOOKUP *)) GET_CRYPTOLIB_SYMBOL(
"X509_LOOKUP_free");
440 K_X509_LOOKUP_ctrl = (int (*)(X509_LOOKUP *, int,
const char *, long,
char **)) GET_CRYPTOLIB_SYMBOL(
"X509_LOOKUP_ctrl");
441 K_X509_STORE_CTX_init = (void (*)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_init");
442 K_X509_dup = (X509* (*)(X509*)) GET_CRYPTOLIB_SYMBOL(
"X509_dup");
443 K_X509_get0_signature = (void (*)(
const ASN1_BIT_STRING **psig,
444 const X509_ALGOR **palg,
const X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_get0_signature");
445 K_BIO_s_mem = (BIO_METHOD *(*) (
void)) GET_CRYPTOLIB_SYMBOL(
"BIO_s_mem");
446 K_BIO_new = (BIO* (*)(BIO_METHOD *)) GET_CRYPTOLIB_SYMBOL(
"BIO_new");
447 K_BIO_new_fp = (BIO* (*)(FILE*,
int)) GET_CRYPTOLIB_SYMBOL(
"BIO_new_fp");
448 K_BIO_new_mem_buf = (BIO* (*)(
void *,
int)) GET_CRYPTOLIB_SYMBOL(
"BIO_new_mem_buf");
449 K_BIO_free = (int (*)(BIO*)) GET_CRYPTOLIB_SYMBOL(
"BIO_free");
450 K_BIO_ctrl = (long (*) (BIO *,int,long,
void *)) GET_CRYPTOLIB_SYMBOL(
"BIO_ctrl");
451 K_BIO_write = (int (*) (BIO *b,
const void *data,
int len)) GET_CRYPTOLIB_SYMBOL(
"BIO_write");
452 K_BIO_get_data = (
void* (*)(BIO *a)) GET_CRYPTOLIB_SYMBOL(
"BIO_get_data");
453 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");
454 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
455 K_ASN1_item_i2d_fp = (int (*)(ASN1_ITEM *, FILE*,
unsigned char *)) GET_CRYPTOLIB_SYMBOL(
"ASN1_item_i2d_fp");
456 K_NETSCAPE_X509_it = (ASN1_ITEM *) GET_CRYPTOLIB_SYMBOL(
"NETSCAPE_X509_it");
458 K_X509_asn1_meth = (ASN1_METHOD* (*)(
void)) GET_CRYPTOLIB_SYMBOL(
"X509_asn1_meth");
459 K_ASN1_i2d_fp = (int (*)(int (*)(), FILE*,
unsigned char *)) GET_CRYPTOLIB_SYMBOL(
"ASN1_i2d_fp");
460 K_i2d_ASN1_HEADER = (int (*)(ASN1_HEADER *,
unsigned char **)) GET_CRYPTOLIB_SYMBOL(
"i2d_ASN1_HEADER");
462 K_X509_print_fp = (int (*)(FILE*, X509*)) GET_CRYPTOLIB_SYMBOL(
"X509_print_fp");
463 K_i2d_PKCS12 = (int (*)(PKCS12*,
unsigned char**)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS12");
464 K_i2d_PKCS12_fp = (int (*)(FILE *, PKCS12*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS12_fp");
465 K_PKCS12_newpass = (int (*)(PKCS12*,
char*,
char*)) GET_CRYPTOLIB_SYMBOL(
"PKCS12_newpass");
466 K_d2i_PKCS12_fp = (PKCS12* (*)(FILE*, PKCS12**)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS12_fp");
467 K_PKCS12_new = (PKCS12* (*)()) GET_CRYPTOLIB_SYMBOL(
"PKCS12_new");
468 K_PKCS12_free = (void (*)(PKCS12 *)) GET_CRYPTOLIB_SYMBOL(
"PKCS12_free");
469 K_PKCS12_parse = (int (*)(PKCS12*,
const char *, EVP_PKEY**,
470 X509**, STACK_OF(X509)**)) GET_CRYPTOLIB_SYMBOL(
"PKCS12_parse");
471 K_EVP_PKEY_free = (void (*) (EVP_PKEY *)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_free");
472 K_EVP_PKEY_new = (EVP_PKEY* (*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_new");
473 K_EVP_PKEY_base_id = (int (*)(
const EVP_PKEY *pkey)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_base_id");
474 K_EVP_PKEY_get0_RSA = (RSA* (*)(EVP_PKEY *pkey)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_get0_RSA");
475 K_EVP_PKEY_get0_DSA = (DSA* (*)(EVP_PKEY *pkey)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_get0_DSA");
476 K_X509_REQ_free = (void (*)(X509_REQ*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_free");
477 K_X509_REQ_new = (X509_REQ* (*)()) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_new");
478 K_X509_STORE_CTX_set0_untrusted = (void (*)(X509_STORE_CTX *, STACK_OF(X509)*)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_set0_untrusted");
479 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");
480 K_X509_STORE_CTX_set_purpose = (void (*)(X509_STORE_CTX *, int)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_set_purpose");
481 K_sk_free = (void (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_free");
482 if (!K_sk_free) K_sk_free = (void (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_free");
483 K_sk_num = (int (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_num");
484 if (!K_sk_num) K_sk_num = (int (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_num");
485 K_sk_pop = (
char* (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_pop");
486 if (!K_sk_pop) K_sk_pop = (
char* (*) (STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_pop");
487 K_sk_value = (
char* (*) (STACK *,
int)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_value");
488 if (!K_sk_value) K_sk_value = (
char* (*) (STACK *,
int)) GET_CRYPTOLIB_SYMBOL(
"sk_value");
489 K_sk_new = (STACK* (*) (
int (*)())) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_new");
490 if (!K_sk_new) K_sk_new = (STACK* (*) (
int (*)())) GET_CRYPTOLIB_SYMBOL(
"sk_new");
491 K_sk_push = (int (*) (STACK*,
char*)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_push");
492 if (!K_sk_push) K_sk_push = (int (*) (STACK*,
char*)) GET_CRYPTOLIB_SYMBOL(
"sk_push");
493 K_sk_dup = (STACK* (*) (
const STACK *)) GET_CRYPTOLIB_SYMBOL(
"OPENSSL_sk_dup");
494 if (!K_sk_dup) K_sk_dup = (STACK* (*) (
const STACK *)) GET_CRYPTOLIB_SYMBOL(
"sk_dup");
495 K_i2s_ASN1_INTEGER = (
char *(*) (X509V3_EXT_METHOD *, ASN1_INTEGER *)) GET_CRYPTOLIB_SYMBOL(
"i2s_ASN1_INTEGER");
496 K_X509_get_serialNumber = (ASN1_INTEGER * (*) (X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_serialNumber");
497 K_X509_get_pubkey = (EVP_PKEY *(*)(X509 *)) GET_CRYPTOLIB_SYMBOL(
"X509_get_pubkey");
498 K_i2d_PublicKey = (int (*)(EVP_PKEY *,
unsigned char **)) GET_CRYPTOLIB_SYMBOL(
"i2d_PublicKey");
499 K_X509_check_private_key = (int (*)(X509 *, EVP_PKEY *)) GET_CRYPTOLIB_SYMBOL(
"X509_check_private_key");
500 K_BN_bn2hex = (
char *(*)(
const BIGNUM *)) GET_CRYPTOLIB_SYMBOL(
"BN_bn2hex");
501 K_X509_digest = (int (*)(
const X509 *,
const EVP_MD *,
unsigned char *,
unsigned int *)) GET_CRYPTOLIB_SYMBOL(
"X509_digest");
502 K_EVP_md5 = (EVP_MD *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_md5");
503 K_ASN1_INTEGER_free = (void (*)(ASN1_INTEGER *)) GET_CRYPTOLIB_SYMBOL(
"ASN1_INTEGER_free");
504 K_OBJ_obj2nid = (int (*)(ASN1_OBJECT *)) GET_CRYPTOLIB_SYMBOL(
"OBJ_obj2nid");
505 K_OBJ_nid2ln = (
const char *(*)(
int)) GET_CRYPTOLIB_SYMBOL(
"OBJ_nid2ln");
506 K_X509_get_ext_count = (int (*)(X509*)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_count");
507 K_X509_get_ext_by_NID = (int (*)(X509*,int,int)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_by_NID");
508 K_X509_get_ext_by_OBJ = (int (*)(X509*,ASN1_OBJECT*,int)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_by_OBJ");
509 K_X509_get_ext = (X509_EXTENSION* (*)(X509*,
int)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext");
510 K_X509_delete_ext = (X509_EXTENSION* (*)(X509*,
int)) GET_CRYPTOLIB_SYMBOL(
"X509_delete_ext");
511 K_X509_add_ext = (int (*)(X509*,X509_EXTENSION*,int)) GET_CRYPTOLIB_SYMBOL(
"X509_add_ext");
512 K_X509_get_ext_d2i = (
void* (*)(X509*,
int,
int*,
int*)) GET_CRYPTOLIB_SYMBOL(
"X509_get_ext_d2i");
513 K_i2s_ASN1_OCTET_STRING = (
char *(*)(X509V3_EXT_METHOD*,ASN1_OCTET_STRING*)) GET_CRYPTOLIB_SYMBOL(
"i2s_ASN1_OCTET_STRING");
514 K_ASN1_BIT_STRING_get_bit = (int (*)(ASN1_BIT_STRING*,int)) GET_CRYPTOLIB_SYMBOL(
"ASN1_BIT_STRING_get_bit");
515 K_PKCS7_new = (PKCS7 *(*)()) GET_CRYPTOLIB_SYMBOL(
"PKCS7_new");
516 K_PKCS7_free = (void (*)(PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_free");
517 K_PKCS7_content_free = (void (*)(PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_content_free");
518 K_i2d_PKCS7 = (int (*)(PKCS7*,
unsigned char**)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS7");
519 K_i2d_PKCS7_fp = (int (*)(FILE*,PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS7_fp");
520 K_i2d_PKCS7_bio = (int (*)(BIO *bp,PKCS7 *p7)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS7_bio");
521 K_d2i_PKCS7 = (PKCS7* (*)(PKCS7**,
unsigned char**,
long)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS7");
522 K_d2i_PKCS7_fp = (PKCS7 *(*)(FILE *,PKCS7**)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS7_fp");
523 K_d2i_PKCS7_bio = (PKCS7 *(*)(BIO *bp,PKCS7 **p7)) GET_CRYPTOLIB_SYMBOL(
"d2i_PKCS7_bio");
524 K_PKCS7_dup = (PKCS7* (*)(PKCS7*)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_dup");
525 K_PKCS7_sign = (PKCS7 *(*)(X509*, EVP_PKEY*, STACK_OF(X509)*, BIO*, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_sign");
526 K_PKCS7_verify = (int (*)(PKCS7*,STACK_OF(X509)*,X509_STORE*,BIO*,BIO*,int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_verify");
527 K_PKCS7_get0_signers = (STACK_OF(X509) *(*)(PKCS7 *, STACK_OF(X509) *, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_get0_signers");
528 K_PKCS7_encrypt = (PKCS7* (*)(STACK_OF(X509) *, BIO *, EVP_CIPHER *, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_encrypt");
529 K_PKCS7_decrypt = (int (*)(PKCS7 *, EVP_PKEY *, X509 *, BIO *, int)) GET_CRYPTOLIB_SYMBOL(
"PKCS7_decrypt");
530 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");
531 K_ASN1_d2i_fp = (
char *(*)(
char *(*)(),
char *(*)(),FILE*,
unsigned char**)) GET_CRYPTOLIB_SYMBOL(
"ASN1_d2i_fp");
532 K_X509_new = (X509 *(*)()) GET_CRYPTOLIB_SYMBOL(
"X509_new");
533 K_X509_PURPOSE_get_count = (int (*)()) GET_CRYPTOLIB_SYMBOL(
"X509_PURPOSE_get_count");
534 K_X509_PURPOSE_get_id = (int (*)(X509_PURPOSE *)) GET_CRYPTOLIB_SYMBOL(
"X509_PURPOSE_get_id");
535 K_X509_check_purpose = (int (*)(X509*,int,int)) GET_CRYPTOLIB_SYMBOL(
"X509_check_purpose");
536 K_X509_PURPOSE_get0 = (X509_PURPOSE *(*)(
int)) GET_CRYPTOLIB_SYMBOL(
"X509_PURPOSE_get0");
537 K_EVP_PKEY_assign = (int (*)(EVP_PKEY*, int,
char*)) GET_CRYPTOLIB_SYMBOL(
"EVP_PKEY_assign");
538 K_X509_REQ_set_pubkey = (int (*)(X509_REQ*, EVP_PKEY*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_set_pubkey");
539 K_RSA_get0_key = (void (*)(
const RSA *r,
const BIGNUM **n,
const BIGNUM **e,
const BIGNUM **d)) GET_CRYPTOLIB_SYMBOL(
"RSA_get0_key");
540 K_RSA_generate_key = (RSA* (*)(
int,
unsigned long,
void (*)(int,int,
void *),
void *)) GET_CRYPTOLIB_SYMBOL(
"RSA_generate_key");
541 K_DSA_get0_pqg = (void (*)(
const DSA *d,
const BIGNUM **p,
const BIGNUM **q,
const BIGNUM **g)) GET_CRYPTOLIB_SYMBOL(
"DSA_get0_pqg");
542 K_DSA_get0_key = (void (*)(
const DSA *d,
const BIGNUM **pub_key,
const BIGNUM **priv_key)) GET_CRYPTOLIB_SYMBOL(
"DSA_get0_key");
543 K_i2d_X509_REQ_fp = (int (*)(FILE *, X509_REQ *)) GET_CRYPTOLIB_SYMBOL(
"i2d_X509_REQ_fp");
544 K_ERR_clear_error = (void (*)()) GET_CRYPTOLIB_SYMBOL(
"ERR_clear_error");
545 K_ERR_get_error = (
unsigned long (*)()) GET_CRYPTOLIB_SYMBOL(
"ERR_get_error");
546 K_ERR_print_errors_fp = (void (*)(FILE*)) GET_CRYPTOLIB_SYMBOL(
"ERR_print_errors_fp");
547 K_X509_get1_email = (STACK *(*)(X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_get1_email");
548 K_X509_email_free = (void (*)(STACK *sk)) GET_CRYPTOLIB_SYMBOL(
"X509_email_free");
549 K_EVP_des_ede3_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_des_ede3_cbc");
550 K_EVP_des_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_des_cbc");
551 K_EVP_rc2_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_rc2_cbc");
552 K_EVP_rc2_64_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_rc2_64_cbc");
553 K_EVP_rc2_40_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_rc2_40_cbc");
554 K_i2d_PrivateKey_fp = (int (*)(FILE*,EVP_PKEY*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PrivateKey_fp");
555 K_i2d_PKCS8PrivateKey_fp = (int (*)(FILE*, EVP_PKEY*,
const EVP_CIPHER*,
char*, int, pem_password_cb*,
void*)) GET_CRYPTOLIB_SYMBOL(
"i2d_PKCS8PrivateKey_fp");
556 K_RSA_free = (void (*)(RSA*)) GET_CRYPTOLIB_SYMBOL(
"RSA_free");
557 K_EVP_bf_cbc = (EVP_CIPHER *(*)()) GET_CRYPTOLIB_SYMBOL(
"EVP_bf_cbc");
558 K_X509_REQ_sign = (int (*)(X509_REQ*, EVP_PKEY*,
const EVP_MD*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_sign");
559 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");
560 K_X509_NAME_new = (X509_NAME *(*)()) GET_CRYPTOLIB_SYMBOL(
"X509_NAME_new");
561 K_X509_REQ_set_subject_name = (int (*)(X509_REQ*,X509_NAME*)) GET_CRYPTOLIB_SYMBOL(
"X509_REQ_set_subject_name");
562 K_ASN1_STRING_data = (
unsigned char *(*)(ASN1_STRING*)) GET_CRYPTOLIB_SYMBOL(
"ASN1_STRING_data");
563 K_ASN1_STRING_length = (int (*)(ASN1_STRING*)) GET_CRYPTOLIB_SYMBOL(
"ASN1_STRING_length");
564 K_X509_CRL_get0_lastUpdate = (
const ASN1_TIME* (*)(
const X509_CRL *crl)) GET_CRYPTOLIB_SYMBOL(
"X509_CRL_get0_lastUpdate");
565 K_X509_CRL_get0_nextUpdate = (
const ASN1_TIME* (*)(
const X509_CRL *crl)) GET_CRYPTOLIB_SYMBOL(
"X509_CRL_get0_nextUpdate");
566 K_X509_STORE_CTX_get_current_cert = (X509* (*)(X509_STORE_CTX *ctx)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_get_current_cert");
567 K_X509_STORE_CTX_get_error = (int (*)(X509_STORE_CTX *ctx)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_get_error");
568 K_X509_STORE_CTX_get_error_depth = (int (*)(X509_STORE_CTX *ctx)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_get_error_depth");
569 K_X509_STORE_CTX_set_error = (void (*)(X509_STORE_CTX *ctx,
int s)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_CTX_set_error");
570 K_X509_STORE_set_verify_cb = (void (*)(X509_STORE *ctx,
571 X509_STORE_CTX_verify_cb verify_cb)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_set_verify_cb");
572 K_X509_STORE_get0_objects = (STACK_OF(X509_OBJECT)* (*)(X509_STORE *v)) GET_CRYPTOLIB_SYMBOL(
"X509_STORE_get0_objects");
573 K_X509_OBJECT_get_type = (X509_LOOKUP_TYPE (*)(
const X509_OBJECT *a)) GET_CRYPTOLIB_SYMBOL(
"X509_OBJECT_get_type");
574 K_X509_OBJECT_get0_X509 = (X509* (*)(
const X509_OBJECT *a)) GET_CRYPTOLIB_SYMBOL(
"X509_OBJECT_get0_X509");
575 K_X509_getm_notAfter = (ASN1_TIME* (*)(
const X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_getm_notAfter");
576 K_X509_getm_notBefore = (ASN1_TIME* (*)(
const X509 *x)) GET_CRYPTOLIB_SYMBOL(
"X509_getm_notBefore");
582 TQString libname = findMostRecentLib(
"/usr/lib",
"ssl");
583 if (!libname.isNull())
584 _sslLib = ll->globalLibrary(libname.latin1());
587 for (TQStringList::Iterator it = libpaths.begin();
588 it != libpaths.end();
590 for (TQStringList::Iterator shit = libnamess.begin();
591 shit != libnamess.end();
594 if (!alib.isEmpty() && !alib.endsWith(
"/"))
597 TQString tmpStr(alib.latin1());
598 tmpStr.replace(TQRegExp(
"\\(.*\\)"),
"");
599 if (!access(tmpStr.latin1(), R_OK))
600 _sslLib = ll->globalLibrary(alib.latin1());
610 K_SSL_connect = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_connect");
611 K_SSL_accept = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_accept");
612 K_SSL_read = (int (*)(SSL *,
void *, int)) GET_SSLLIB_SYMBOL(
"SSL_read");
613 K_SSL_write = (int (*)(SSL *,
const void *, int))
614 GET_SSLLIB_SYMBOL(
"SSL_write");
615 K_SSL_new = (SSL* (*)(SSL_CTX *)) GET_SSLLIB_SYMBOL(
"SSL_new");
616 K_SSL_free = (void (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_free");
617 K_SSL_shutdown = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_shutdown");
618 K_SSL_CTX_new = (SSL_CTX* (*)(SSL_METHOD*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_new");
619 K_SSL_CTX_free = (void (*)(SSL_CTX*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_free");
620 K_SSL_set_fd = (int (*)(SSL *, int)) GET_SSLLIB_SYMBOL(
"SSL_set_fd");
621 K_SSL_pending = (int (*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_pending");
622 K_SSL_CTX_set_cipher_list = (int (*)(SSL_CTX *,
const char *))
623 GET_SSLLIB_SYMBOL(
"SSL_CTX_set_cipher_list");
624 K_SSL_CTX_set_verify = (void (*)(SSL_CTX*, int, int (*)(int, X509_STORE_CTX*))) GET_SSLLIB_SYMBOL(
"SSL_CTX_set_verify");
625 K_SSL_use_certificate = (int (*)(SSL*, X509*))
626 GET_SSLLIB_SYMBOL(
"SSL_CTX_use_certificate");
627 K_SSL_get_current_cipher = (SSL_CIPHER *(*)(SSL *))
628 GET_SSLLIB_SYMBOL(
"SSL_get_current_cipher");
629 K_SSL_set_options = (long (*)(SSL *ssl,
long options)) GET_SSLLIB_SYMBOL(
"SSL_set_options");
630 K_SSL_session_reused = (int (*)(SSL *ssl)) GET_SSLLIB_SYMBOL(
"SSL_session_reused");
631 K_SSL_ctrl = (long (*)(SSL * ,int, long,
void *))
632 GET_SSLLIB_SYMBOL(
"SSL_ctrl");
633 K_TLSv1_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"TLSv1_client_method");
634 K_SSLv2_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"SSLv2_client_method");
635 K_SSLv3_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"SSLv3_client_method");
636 K_TLS_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"TLS_client_method");
637 if (!K_TLS_client_method) K_TLS_client_method = (SSL_METHOD *(*)()) GET_SSLLIB_SYMBOL(
"SSLv23_client_method");
638 K_SSL_get_peer_certificate = (X509 *(*)(SSL *)) GET_SSLLIB_SYMBOL(
"SSL_get_peer_certificate");
639 K_SSL_CIPHER_get_bits = (int (*)(SSL_CIPHER *,
int *)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_get_bits");
640 K_SSL_CIPHER_get_version = (
char * (*)(SSL_CIPHER *)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_get_version");
641 K_SSL_CIPHER_get_name = (
const char * (*)(SSL_CIPHER *)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_get_name");
642 K_SSL_CIPHER_description = (
char * (*)(SSL_CIPHER *,
char *,
int)) GET_SSLLIB_SYMBOL(
"SSL_CIPHER_description");
643 K_SSL_CTX_use_PrivateKey = (int (*)(SSL_CTX*, EVP_PKEY*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_use_PrivateKey");
644 K_SSL_CTX_use_certificate = (int (*)(SSL_CTX*, X509*)) GET_SSLLIB_SYMBOL(
"SSL_CTX_use_certificate");
645 K_SSL_get_error = (int (*)(SSL*, int)) GET_SSLLIB_SYMBOL(
"SSL_get_error");
646 K_SSL_get_peer_cert_chain = (STACK_OF(X509)* (*)(SSL*)) GET_SSLLIB_SYMBOL(
"SSL_get_peer_cert_chain");
647 K_SSL_load_client_CA_file = (STACK_OF(X509_NAME)* (*)(
const char *)) GET_SSLLIB_SYMBOL(
"SSL_load_client_CA_file");
648 K_SSL_peek = (int (*)(SSL*,
void*,int)) GET_SSLLIB_SYMBOL(
"SSL_peek");
649 K_SSL_get1_session = (SSL_SESSION* (*)(SSL*)) GET_SSLLIB_SYMBOL(
"SSL_get1_session");
650 K_SSL_SESSION_free = (void (*)(SSL_SESSION*)) GET_SSLLIB_SYMBOL(
"SSL_SESSION_free");
651 K_SSL_set_session = (int (*)(SSL*,SSL_SESSION*)) GET_SSLLIB_SYMBOL(
"SSL_set_session");
652 K_d2i_SSL_SESSION = (SSL_SESSION* (*)(SSL_SESSION**,
unsigned char**,
long)) GET_SSLLIB_SYMBOL(
"d2i_SSL_SESSION");
653 K_i2d_SSL_SESSION = (int (*)(SSL_SESSION*,
unsigned char**)) GET_SSLLIB_SYMBOL(
"i2d_SSL_SESSION");
654 K_SSL_get_ciphers = (STACK_OF(SSL_CIPHER) *(*)(
const SSL*)) GET_SSLLIB_SYMBOL(
"SSL_get_ciphers");
660 x = GET_SSLLIB_SYMBOL(
"OPENSSL_init_ssl");
664 ((int (*)(
unsigned long long,
void*))x)(0, NULL);
665 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_init_crypto");
666 if (x) ((int (*)(
unsigned long long,
void*))x)(OPENSSL_INIT_ADD_ALL_CIPHERS
667 | OPENSSL_INIT_ADD_ALL_DIGESTS
668 | OPENSSL_INIT_LOAD_CONFIG,
674 x = GET_SSLLIB_SYMBOL(
"SSL_library_init");
676 if (x) ((int (*)())x)();
677 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_algorithms");
679 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_algorithms");
683 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_algorithms_conf");
685 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_algorithms_conf");
689 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_algorithms_noconf");
691 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_algorithms_noconf");
696 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_ciphers");
698 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_ciphers");
699 if (x) ((void (*)())x)();
700 x = GET_CRYPTOLIB_SYMBOL(
"OpenSSL_add_all_digests");
702 x = GET_CRYPTOLIB_SYMBOL(
"OPENSSL_add_all_digests");
703 if (x) ((void (*)())x)();
712 static KStaticDeleter<KOpenSSLProxy> medProxy;
716 KOpenSSLProxy::~KOpenSSLProxy() {
721 _cryptoLib->unload();
723 medProxy.setObject(0);
748 int KOpenSSLProxy::SSL_connect(SSL *ssl) {
749 if (K_SSL_connect)
return (K_SSL_connect)(ssl);
750 kdWarning() <<
"SSL_connect not defined!" << endl;
755 int KOpenSSLProxy::SSL_accept(SSL *ssl) {
756 if (K_SSL_accept)
return (K_SSL_accept)(ssl);
757 kdWarning() <<
"SSL_accept not defined!" << endl;
762 int KOpenSSLProxy::SSL_read(SSL *ssl,
void *buf,
int num) {
763 if (K_SSL_read)
return (K_SSL_read)(ssl, buf, num);
764 kdWarning() <<
"SSL_read not defined!" << endl;
769 int KOpenSSLProxy::SSL_write(SSL *ssl,
const void *buf,
int num) {
770 if (K_SSL_write)
return (K_SSL_write)(ssl, buf, num);
771 kdWarning() <<
"SSL_write not defined!" << endl;
776 SSL *KOpenSSLProxy::SSL_new(SSL_CTX *ctx) {
777 if (K_SSL_new)
return (K_SSL_new)(ctx);
778 kdWarning() <<
"SSL_new not defined!" << endl;
783 void KOpenSSLProxy::SSL_free(SSL *ssl) {
784 if (K_SSL_free) (K_SSL_free)(ssl);
785 else kdWarning() <<
"SSL_free not defined!" << endl;
789 int KOpenSSLProxy::SSL_shutdown(SSL *ssl) {
790 if (K_SSL_shutdown)
return (K_SSL_shutdown)(ssl);
791 kdWarning() <<
"SSL_shutdown not defined!" << endl;
796 SSL_CTX *KOpenSSLProxy::SSL_CTX_new(SSL_METHOD *method) {
797 if (K_SSL_CTX_new)
return (K_SSL_CTX_new)(method);
798 kdWarning() <<
"SSL_CTX_new not defined!" << endl;
803 void KOpenSSLProxy::SSL_CTX_free(SSL_CTX *ctx) {
804 if (K_SSL_CTX_free) (K_SSL_CTX_free)(ctx);
805 else kdWarning() <<
"SSL_CTX_free not defined!" << endl;
809 int KOpenSSLProxy::SSL_set_fd(SSL *ssl,
int fd) {
810 if (K_SSL_set_fd)
return (K_SSL_set_fd)(ssl, fd);
811 kdWarning() <<
"SSL_sed_fd not defined!" << endl;
816 int KOpenSSLProxy::SSL_pending(SSL *ssl) {
817 if (K_SSL_pending)
return (K_SSL_pending)(ssl);
818 kdWarning() <<
"SSL_pending not defined!" << endl;
823 int KOpenSSLProxy::SSL_CTX_set_cipher_list(SSL_CTX *ctx,
const char *str) {
824 if (K_SSL_CTX_set_cipher_list)
return (K_SSL_CTX_set_cipher_list)(ctx, str);
825 kdWarning() <<
"SSL_CTX_set_cipher_list not defined!" << endl;
830 void KOpenSSLProxy::SSL_CTX_set_verify(SSL_CTX *ctx,
int mode,
831 int (*verify_callback)(
int, X509_STORE_CTX *)) {
832 if (K_SSL_CTX_set_verify) (K_SSL_CTX_set_verify)(ctx, mode, verify_callback);
833 else kdWarning() <<
"SSL_CTX_set_verify not defined!" << endl;
837 int KOpenSSLProxy::SSL_use_certificate(SSL *ssl, X509 *x) {
838 if (K_SSL_use_certificate)
return (K_SSL_use_certificate)(ssl, x);
839 kdWarning() <<
"SSL_use_certificate not defined!" << endl;
844 SSL_CIPHER *KOpenSSLProxy::SSL_get_current_cipher(SSL *ssl) {
845 if (K_SSL_get_current_cipher)
return (K_SSL_get_current_cipher)(ssl);
846 kdWarning() <<
"SSL_get_current_cipher not defined!" << endl;
851 long KOpenSSLProxy::_SSL_set_options(SSL *ssl,
long options) {
852 if (K_SSL_set_options)
return (K_SSL_set_options)(ssl, options);
853 #if OPENSSL_VERSION_NUMBER < 0x10100000L
854 return this->SSL_set_options(ssl, options);
856 kdWarning() <<
"SSL_set_options not defined!" << endl;
861 int KOpenSSLProxy::_SSL_session_reused(SSL *ssl) {
862 if (K_SSL_session_reused)
return (K_SSL_session_reused)(ssl);
863 #if OPENSSL_VERSION_NUMBER < 0x10100000L
864 return this->SSL_session_reused(ssl);
866 kdWarning() <<
"SSL_session_reused not defined!" << endl;
871 long KOpenSSLProxy::SSL_ctrl(SSL *ssl,
int cmd,
long larg,
void *parg) {
872 if (K_SSL_ctrl)
return (K_SSL_ctrl)(ssl, cmd, larg, parg);
873 kdWarning() <<
"SSL_ctrl not defined!" << endl;
878 int KOpenSSLProxy::RAND_egd(
const char *path) {
879 if (K_RAND_egd)
return (K_RAND_egd)(path);
880 kdWarning() <<
"RAND_egd not defined!" << endl;
885 SSL_METHOD *KOpenSSLProxy::TLSv1_client_method() {
886 if (K_TLSv1_client_method)
return (K_TLSv1_client_method)();
887 kdWarning() <<
"TLSv1_client_method not defined!" << endl;
892 SSL_METHOD *KOpenSSLProxy::SSLv2_client_method() {
893 if (K_SSLv2_client_method)
return (K_SSLv2_client_method)();
894 kdWarning() <<
"SSLv2_client_method not defined!" << endl;
899 SSL_METHOD *KOpenSSLProxy::SSLv3_client_method() {
900 if (K_SSLv3_client_method)
return (K_SSLv3_client_method)();
901 kdWarning() <<
"SSLv3_client_method not defined!" << endl;
906 SSL_METHOD *KOpenSSLProxy::TLS_client_method() {
907 if (K_TLS_client_method)
return (K_TLS_client_method)();
908 kdWarning() <<
"TLS_client_method not defined!" << endl;
913 X509 *KOpenSSLProxy::SSL_get_peer_certificate(SSL *s) {
914 if (K_SSL_get_peer_certificate)
return (K_SSL_get_peer_certificate)(s);
915 kdWarning() <<
"SSL_get_peer_certificate not defined!" << endl;
920 int KOpenSSLProxy::SSL_CIPHER_get_bits(SSL_CIPHER *c,
int *alg_bits) {
921 if (K_SSL_CIPHER_get_bits)
return (K_SSL_CIPHER_get_bits)(c, alg_bits);
922 kdWarning() <<
"SSL_CIPHER_get_bits not defined!" << endl;
927 char * KOpenSSLProxy::SSL_CIPHER_get_version(SSL_CIPHER *c) {
928 if (K_SSL_CIPHER_get_version)
return (K_SSL_CIPHER_get_version)(c);
929 kdWarning() <<
"SSL_CIPHER_get_version not defined!" << endl;
934 const char * KOpenSSLProxy::SSL_CIPHER_get_name(SSL_CIPHER *c) {
935 if (K_SSL_CIPHER_get_name)
return (K_SSL_CIPHER_get_name)(c);
936 kdWarning() <<
"SSL_CIPHER_get_name not defined!" << endl;
941 char * KOpenSSLProxy::SSL_CIPHER_description(SSL_CIPHER *c,
char *buf,
int size) {
942 if (K_SSL_CIPHER_description)
return (K_SSL_CIPHER_description)(c,buf,size);
943 kdWarning() <<
"SSL_CIPHER_description not defined!" << endl;
948 X509 * KOpenSSLProxy::d2i_X509(X509 **a,
unsigned char **pp,
long length) {
949 if (K_d2i_X509)
return (K_d2i_X509)(a,pp,length);
950 kdWarning() <<
"d2i_X509 not defined!" << endl;
955 X509_CRL * KOpenSSLProxy::d2i_X509_CRL(X509_CRL **a,
unsigned char **pp,
long length) {
956 if (K_d2i_X509_CRL)
return (K_d2i_X509_CRL)(a,pp,length);
957 kdWarning() <<
"d2i_X509_CRL not defined!" << endl;
962 int KOpenSSLProxy::i2d_X509(X509 *a,
unsigned char **pp) {
963 if (K_i2d_X509)
return (K_i2d_X509)(a,pp);
964 kdWarning() <<
"i2d_X509 not defined!" << endl;
969 int KOpenSSLProxy::X509_cmp(X509 *a, X509 *b) {
970 if (K_X509_cmp)
return (K_X509_cmp)(a,b);
971 kdWarning() <<
"X509_cmp not defined!" << endl;
976 int KOpenSSLProxy::X509_subject_name_cmp(
const X509 *a,
const X509 *b) {
977 if (K_X509_subject_name_cmp)
return (K_X509_subject_name_cmp)(a, b);
978 kdWarning() <<
"X509_subject_name_cmp not defined!" << endl;
983 X509_STORE *KOpenSSLProxy::X509_STORE_new(
void) {
984 if (K_X509_STORE_new)
return (K_X509_STORE_new)();
985 kdWarning() <<
"X509_STORE_new not defined!" << endl;
990 void KOpenSSLProxy::X509_STORE_free(X509_STORE *v) {
991 if (K_X509_STORE_free) (K_X509_STORE_free)(v);
992 else kdWarning() <<
"X509_STORE_free not defined!" << endl;
996 X509_STORE_CTX *KOpenSSLProxy::X509_STORE_CTX_new(
void) {
997 if (K_X509_STORE_CTX_new)
return (K_X509_STORE_CTX_new)();
998 kdWarning() <<
"X509_STORE_CTX_new not defined!" << endl;
1003 void KOpenSSLProxy::X509_STORE_CTX_free(X509_STORE_CTX *ctx) {
1004 if (K_X509_STORE_CTX_free) (K_X509_STORE_CTX_free)(ctx);
1005 else kdWarning() <<
"X509_STORE_CTX_free not defined!" << endl;
1009 int KOpenSSLProxy::X509_verify_cert(X509_STORE_CTX *ctx) {
1010 if (K_X509_verify_cert)
return (K_X509_verify_cert)(ctx);
1011 kdWarning() <<
"X509_verify_cert not defined!" << endl;
1016 void KOpenSSLProxy::X509_free(X509 *a) {
1017 if (K_X509_free) (K_X509_free)(a);
1018 else kdWarning() <<
"X509_free not defined!" << endl;
1022 void KOpenSSLProxy::X509_CRL_free(X509_CRL *a) {
1023 if (K_X509_CRL_free) (K_X509_CRL_free)(a);
1024 else kdWarning() <<
"X509_CRL_free not defined!" << endl;
1028 char *KOpenSSLProxy::X509_NAME_oneline(X509_NAME *a,
char *buf,
int size) {
1029 if (K_X509_NAME_oneline)
return (K_X509_NAME_oneline)(a,buf,size);
1030 kdWarning() <<
"X509_NAME_online not defined!" << endl;
1035 X509_NAME *KOpenSSLProxy::X509_get_subject_name(X509 *a) {
1036 if (K_X509_get_subject_name)
return (K_X509_get_subject_name)(a);
1037 kdWarning() <<
"X509_get_subject not defined!" << endl;
1042 X509_NAME *KOpenSSLProxy::X509_get_issuer_name(X509 *a) {
1043 if (K_X509_get_issuer_name)
return (K_X509_get_issuer_name)(a);
1044 kdWarning() <<
"X509_get_issuer not defined!" << endl;
1049 X509_LOOKUP *KOpenSSLProxy::X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m) {
1050 if (K_X509_STORE_add_lookup)
return (K_X509_STORE_add_lookup)(v,m);
1051 kdWarning() <<
"X509_STORE_add_lookup not defined!" << endl;
1056 X509_LOOKUP_METHOD *KOpenSSLProxy::X509_LOOKUP_file(
void) {
1057 if (K_X509_LOOKUP_file)
return (K_X509_LOOKUP_file)();
1058 kdWarning() <<
"X509_LOOKUP_file not defined!" << endl;
1063 void KOpenSSLProxy::X509_LOOKUP_free(X509_LOOKUP *x) {
1064 if (K_X509_LOOKUP_free) (K_X509_LOOKUP_free)(x);
1065 else kdWarning() <<
"X509_LOOKUP_free not defined!" << endl;
1069 int KOpenSSLProxy::X509_LOOKUP_ctrl(X509_LOOKUP *ctx,
int cmd,
const char *argc,
long argl,
char **ret) {
1070 if (K_X509_LOOKUP_ctrl)
return (K_X509_LOOKUP_ctrl)(ctx,cmd,argc,argl,ret);
1071 kdWarning() <<
"X509_LOOKUP_ctrl not defined!" << endl;
1076 void KOpenSSLProxy::X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, STACK_OF(X509) *chain) {
1077 if (K_X509_STORE_CTX_init) (K_X509_STORE_CTX_init)(ctx,store,x509,chain);
1078 else kdWarning() <<
"X509_STORE_CTX_init not defined!" << endl;
1082 void KOpenSSLProxy::CRYPTO_free(
void *x) {
1083 if (K_CRYPTO_free) (K_CRYPTO_free)(x);
1084 else kdWarning() <<
"CRYPTO_free not defined!" << endl;
1088 X509 *KOpenSSLProxy::X509_dup(X509 *x509) {
1089 if (K_X509_dup)
return (K_X509_dup)(x509);
1090 kdWarning() <<
"X509_dup not defined!" << endl;
1095 void KOpenSSLProxy::X509_get0_signature(
const ASN1_BIT_STRING **psig,
1096 const X509_ALGOR **palg,
const X509 *x) {
1097 if (K_X509_get0_signature) {
1098 (X509_get0_signature)(psig, palg, x);
1101 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1103 if (psig) *psig = x->signature;
1104 if (palg) *palg = x->sig_alg;
1107 kdWarning() <<
"X509_get0_signature not defined!" << endl;
1111 BIO *KOpenSSLProxy::BIO_new(BIO_METHOD *type) {
1112 if (K_BIO_new)
return (K_BIO_new)(type);
1113 kdWarning() <<
"BIO_new not defined!" << endl;
1118 BIO_METHOD *KOpenSSLProxy::BIO_s_mem(
void) {
1119 if (K_BIO_s_mem)
return (K_BIO_s_mem)();
1120 kdWarning() <<
"BIO_s_mem not defined!" << endl;
1125 BIO *KOpenSSLProxy::BIO_new_fp(FILE *stream,
int close_flag) {
1126 if (K_BIO_new_fp)
return (K_BIO_new_fp)(stream, close_flag);
1127 kdWarning() <<
"BIO_new_fp not defined!" << endl;
1132 BIO *KOpenSSLProxy::BIO_new_mem_buf(
void *buf,
int len) {
1133 if (K_BIO_new_mem_buf)
return (K_BIO_new_mem_buf)(buf,len);
1134 kdWarning() <<
"BIO_new_mem_buf not defined!" << endl;
1139 int KOpenSSLProxy::BIO_free(BIO *a) {
1140 if (K_BIO_free)
return (K_BIO_free)(a);
1141 kdWarning() <<
"BIO_free not defined!" << endl;
1146 long KOpenSSLProxy::BIO_ctrl(BIO *bp,
int cmd,
long larg,
void *parg) {
1147 if (K_BIO_ctrl)
return (K_BIO_ctrl)(bp,cmd,larg,parg);
1148 kdWarning() <<
"BIO_ctrl not defined!" << endl;
1153 int KOpenSSLProxy::BIO_write(BIO *b,
const void *data,
int len) {
1154 if (K_BIO_write)
return (K_BIO_write)(b, data, len);
1155 kdWarning() <<
"BIO_write not defined!" << endl;
1160 void *KOpenSSLProxy::BIO_get_data(BIO *a) {
1161 if (K_BIO_get_data)
return (K_BIO_get_data)(a);
1162 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1165 kdWarning() <<
"BIO_get_data not defined!" << endl;
1170 int KOpenSSLProxy::PEM_write_bio_X509(BIO *bp, X509 *x) {
1171 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);
1172 kdWarning() <<
"PEM_write_bio_X509 not defined!" << endl;
1176 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
1177 int KOpenSSLProxy::ASN1_i2d_fp(FILE *out,
unsigned char *x) {
1178 if (K_ASN1_item_i2d_fp && K_NETSCAPE_X509_it)
1179 return (K_ASN1_item_i2d_fp)(K_NETSCAPE_X509_it, out, x);
1180 kdWarning() <<
"ANS1_i2d_fp not defined!" << endl;
1184 ASN1_METHOD *KOpenSSLProxy::X509_asn1_meth(
void) {
1185 if (K_X509_asn1_meth)
return (K_X509_asn1_meth)();
1186 kdWarning() <<
"X509_ans1_meth not defined!" << endl;
1191 int KOpenSSLProxy::ASN1_i2d_fp(FILE *out,
unsigned char *x) {
1192 if (K_ASN1_i2d_fp && K_i2d_ASN1_HEADER)
1193 return (K_ASN1_i2d_fp)((int (*)())K_i2d_ASN1_HEADER, out, x);
1194 kdWarning() <<
"ANS1_i2d_fp not defined!" << endl;
1199 int KOpenSSLProxy::X509_print(FILE *fp, X509 *x) {
1200 if (K_X509_print_fp)
return (K_X509_print_fp)(fp, x);
1201 kdWarning() <<
"X509_print not defined!" << endl;
1206 PKCS12 *KOpenSSLProxy::d2i_PKCS12_fp(FILE *fp, PKCS12 **p12) {
1207 if (K_d2i_PKCS12_fp)
return (K_d2i_PKCS12_fp)(fp, p12);
1208 kdWarning() <<
"d2i_PKCS12_fp not defined!" << endl;
1213 int KOpenSSLProxy::PKCS12_newpass(PKCS12 *p12,
char *oldpass,
char *newpass) {
1214 if (K_PKCS12_newpass)
return (K_PKCS12_newpass)(p12, oldpass, newpass);
1215 kdWarning() <<
"PKCS12_newpass not defined!" << endl;
1220 int KOpenSSLProxy::i2d_PKCS12(PKCS12 *p12,
unsigned char **p) {
1221 if (K_i2d_PKCS12)
return (K_i2d_PKCS12)(p12, p);
1222 kdWarning() <<
"i2d_PKCS12 not defined!" << endl;
1227 int KOpenSSLProxy::i2d_PKCS12_fp(FILE *fp, PKCS12 *p12) {
1228 if (K_i2d_PKCS12_fp)
return (K_i2d_PKCS12_fp)(fp, p12);
1229 kdWarning() <<
"i2d_PKCS12_fp not defined!" << endl;
1234 PKCS12 *KOpenSSLProxy::PKCS12_new(
void) {
1235 if (K_PKCS12_new)
return (K_PKCS12_new)();
1236 kdWarning() <<
"PKCS12_new not defined!" << endl;
1241 void KOpenSSLProxy::PKCS12_free(PKCS12 *a) {
1242 if (K_PKCS12_free) (K_PKCS12_free)(a);
1243 else kdWarning() <<
"PKCS12_free not defined!" << endl;
1247 int KOpenSSLProxy::PKCS12_parse(PKCS12 *p12,
const char *pass, EVP_PKEY **pkey,
1248 X509 **cert, STACK_OF(X509) **ca) {
1249 if (K_PKCS12_parse)
return (K_PKCS12_parse) (p12, pass, pkey, cert, ca);
1250 kdWarning() <<
"PKCS12_parse not defined!" << endl;
1255 void KOpenSSLProxy::EVP_PKEY_free(EVP_PKEY *x) {
1256 if (K_EVP_PKEY_free) (K_EVP_PKEY_free)(x);
1257 else kdWarning() <<
"EVP_PKEY_free not defined!" << endl;
1261 EVP_PKEY* KOpenSSLProxy::EVP_PKEY_new() {
1262 if (K_EVP_PKEY_new)
return (K_EVP_PKEY_new)();
1263 kdWarning() <<
"EVP_PKEY_new not defined!" << endl;
1268 int KOpenSSLProxy::EVP_PKEY_base_id(
const EVP_PKEY *pkey) {
1269 if (K_EVP_PKEY_base_id)
return (K_EVP_PKEY_base_id)(pkey);
1270 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1273 kdWarning() <<
"EVP_PKEY_base_id not defined!" << endl;
1278 RSA* KOpenSSLProxy::EVP_PKEY_get0_RSA(EVP_PKEY *pkey) {
1279 if (K_EVP_PKEY_get0_RSA)
return (K_EVP_PKEY_get0_RSA)(pkey);
1280 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1281 return pkey->pkey.rsa;
1283 kdWarning() <<
"EVP_PKEY_get0_RSA not defined!" << endl;
1288 DSA* KOpenSSLProxy::EVP_PKEY_get0_DSA(EVP_PKEY *pkey) {
1289 if (K_EVP_PKEY_get0_DSA)
return (K_EVP_PKEY_get0_DSA)(pkey);
1290 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1291 return pkey->pkey.dsa;
1293 kdWarning() <<
"EVP_PKEY_get0_DSA not defined!" << endl;
1298 void KOpenSSLProxy::X509_REQ_free(X509_REQ *x) {
1299 if (K_X509_REQ_free) (K_X509_REQ_free)(x);
1300 else kdWarning() <<
"X509_REQ_free not defined!" << endl;
1304 X509_REQ* KOpenSSLProxy::X509_REQ_new() {
1305 if (K_X509_REQ_new)
return (K_X509_REQ_new)();
1306 kdWarning() <<
"X509_REQ_new not defined!" << endl;
1311 int KOpenSSLProxy::SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey) {
1312 if (K_SSL_CTX_use_PrivateKey)
return (K_SSL_CTX_use_PrivateKey)(ctx,pkey);
1313 kdWarning() <<
"SSL_CTX_use_PrivateKey not defined!" << endl;
1318 int KOpenSSLProxy::SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x) {
1319 if (K_SSL_CTX_use_certificate)
return (K_SSL_CTX_use_certificate)(ctx,x);
1320 kdWarning() <<
"SSL_CTX_use_certificate not defined!" << endl;
1325 int KOpenSSLProxy::SSL_get_error(SSL *ssl,
int rc) {
1326 if (K_SSL_get_error)
return (K_SSL_get_error)(ssl,rc);
1327 kdWarning() <<
"SSL_get_error not defined!" << endl;
1332 STACK_OF(X509) *KOpenSSLProxy::SSL_get_peer_cert_chain(SSL *s) {
1333 if (K_SSL_get_peer_cert_chain)
return (K_SSL_get_peer_cert_chain)(s);
1334 kdWarning() <<
"SSL_get_peer_cert_chain not defined!" << endl;
1339 void KOpenSSLProxy::OPENSSL_sk_free(STACK *s) {
1340 if (K_sk_free) (K_sk_free)(s);
1341 else kdWarning() <<
"OPENSSL_sk_free not defined!" << endl;
1345 int KOpenSSLProxy::OPENSSL_sk_num(STACK *s) {
1346 if (K_sk_num)
return (K_sk_num)(s);
1347 kdWarning() <<
"OPENSSL_sk_num not defined!" << endl;
1352 char *KOpenSSLProxy::OPENSSL_sk_pop(STACK *s) {
1353 if (K_sk_pop)
return (K_sk_pop)(s);
1354 kdWarning() <<
"OPENSSL_sk_pop not defined!" << endl;
1359 char *KOpenSSLProxy::OPENSSL_sk_value(STACK *s,
int n) {
1360 if (K_sk_value)
return (K_sk_value)(s, n);
1361 kdWarning() <<
"OPENSSL_sk_value not defined!" << endl;
1366 void KOpenSSLProxy::X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *v, STACK_OF(X509)* x) {
1367 if (K_X509_STORE_CTX_set0_untrusted) (K_X509_STORE_CTX_set0_untrusted)(v,x);
1368 else kdWarning() <<
"X509_STORE_CTX_set0_untrusted not defined!" << endl;
1371 void KOpenSSLProxy::X509_STORE_CTX_set_purpose(X509_STORE_CTX *v,
int purpose) {
1372 if (K_X509_STORE_CTX_set_purpose) (K_X509_STORE_CTX_set_purpose)(v,purpose);
1373 else kdWarning() <<
"X509_STORE_CTX_set_purpose not defined!" << endl;
1377 STACK* KOpenSSLProxy::OPENSSL_sk_dup(
const STACK *s) {
1378 if (K_sk_dup)
return (K_sk_dup)(s);
1379 kdWarning() <<
"OPENSSL_sk_dup not defined!" << endl;
1384 STACK* KOpenSSLProxy::OPENSSL_sk_new(
int (*cmp)()) {
1385 if (K_sk_new)
return (K_sk_new)(cmp);
1386 kdWarning() <<
"OPENSSL_sk_new not defined!" << endl;
1391 int KOpenSSLProxy::OPENSSL_sk_push(STACK* s,
char* d) {
1392 if (K_sk_push)
return (K_sk_push)(s,d);
1393 kdWarning() <<
"OPENSSL_sk_push not defined!" << endl;
1398 char *KOpenSSLProxy::i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, ASN1_INTEGER *aint) {
1399 if (K_i2s_ASN1_INTEGER)
return (K_i2s_ASN1_INTEGER)(meth, aint);
1400 kdWarning() <<
"i2s_ANS1_INTEGER not defined!" << endl;
1405 ASN1_INTEGER *KOpenSSLProxy::X509_get_serialNumber(X509 *x) {
1406 if (K_X509_get_serialNumber)
return (K_X509_get_serialNumber)(x);
1407 kdWarning() <<
"X509_get_serialNumber not defined!" << endl;
1412 EVP_PKEY *KOpenSSLProxy::X509_get_pubkey(X509 *x) {
1413 if (K_X509_get_pubkey)
return (K_X509_get_pubkey)(x);
1414 kdWarning() <<
"X59_get_pubkey not defined!" << endl;
1419 int KOpenSSLProxy::i2d_PublicKey(EVP_PKEY *a,
unsigned char **pp) {
1420 if (K_i2d_PublicKey)
return (K_i2d_PublicKey)(a,pp);
1421 kdWarning() <<
"i2d_PublicKey not defined!" << endl;
1426 int KOpenSSLProxy::X509_check_private_key(X509 *x, EVP_PKEY *p) {
1427 if (K_X509_check_private_key)
return (K_X509_check_private_key)(x,p);
1428 kdWarning() <<
"X509_check_private_key not defined!" << endl;
1433 char *KOpenSSLProxy::BN_bn2hex(
const BIGNUM *a) {
1434 if (K_BN_bn2hex)
return (K_BN_bn2hex)(a);
1435 kdWarning() <<
"BN_bn2hex not defined!" << endl;
1440 int KOpenSSLProxy::X509_digest(
const X509 *x,
const EVP_MD *t,
unsigned char *md,
unsigned int *len) {
1441 if (K_X509_digest)
return (K_X509_digest)(x, t, md, len);
1442 kdWarning() <<
"X509_digest not defined!" << endl;
1447 EVP_MD *KOpenSSLProxy::EVP_md5() {
1448 if (K_EVP_md5)
return (K_EVP_md5)();
1449 kdWarning() <<
"EVP_md5 not defined!" << endl;
1454 void KOpenSSLProxy::ASN1_INTEGER_free(ASN1_INTEGER *a) {
1455 if (K_ASN1_INTEGER_free) (K_ASN1_INTEGER_free)(a);
1456 else kdWarning() <<
"ANS1_INTEGER_free not defined!" << endl;
1460 int KOpenSSLProxy::OBJ_obj2nid(ASN1_OBJECT *o) {
1461 if (K_OBJ_obj2nid)
return (K_OBJ_obj2nid)(o);
1462 kdWarning() <<
"OBJ_obj2nid not defined!" << endl;
1467 const char * KOpenSSLProxy::OBJ_nid2ln(
int n) {
1468 if (K_OBJ_nid2ln)
return (K_OBJ_nid2ln)(n);
1469 kdWarning() <<
"OBJ_nid2ln not defined!" << endl;
1474 int KOpenSSLProxy::X509_get_ext_count(X509 *x) {
1475 if (K_X509_get_ext_count)
return (K_X509_get_ext_count)(x);
1476 kdWarning() <<
"X509_get_ext_count not defined!" << endl;
1481 int KOpenSSLProxy::X509_get_ext_by_NID(X509 *x,
int nid,
int lastpos) {
1482 if (K_X509_get_ext_by_NID)
return (K_X509_get_ext_by_NID)(x,nid,lastpos);
1483 kdWarning() <<
"X509_get_ext_by_NID not defined!" << endl;
1488 int KOpenSSLProxy::X509_get_ext_by_OBJ(X509 *x,ASN1_OBJECT *obj,
int lastpos) {
1489 if (K_X509_get_ext_by_OBJ)
return (K_X509_get_ext_by_OBJ)(x,obj,lastpos);
1490 kdWarning() <<
"X509_get_ext_by_OBJ not defined!" << endl;
1495 X509_EXTENSION *KOpenSSLProxy::X509_get_ext(X509 *x,
int loc) {
1496 if (K_X509_get_ext)
return (K_X509_get_ext)(x,loc);
1497 kdWarning() <<
"X509_get_ext not defined!" << endl;
1502 X509_EXTENSION *KOpenSSLProxy::X509_delete_ext(X509 *x,
int loc) {
1503 if (K_X509_delete_ext)
return (K_X509_delete_ext)(x,loc);
1504 kdWarning() <<
"X509_delete_ext not defined!" << endl;
1509 int KOpenSSLProxy::X509_add_ext(X509 *x, X509_EXTENSION *ex,
int loc) {
1510 if (K_X509_add_ext)
return (K_X509_add_ext)(x,ex,loc);
1511 kdWarning() <<
"X509_add_ext not defined!" << endl;
1516 void *KOpenSSLProxy::X509_get_ext_d2i(X509 *x,
int nid,
int *crit,
int *idx) {
1517 if (K_X509_get_ext_d2i)
return (K_X509_get_ext_d2i)(x,nid,crit,idx);
1518 kdWarning() <<
"X509_get_ext_d2i not defined!" << endl;
1523 char *KOpenSSLProxy::i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *ia5) {
1524 if (K_i2s_ASN1_OCTET_STRING)
return (K_i2s_ASN1_OCTET_STRING)(method,ia5);
1525 kdWarning() <<
"i2s_ANS1_OCTET_STRING not defined!" << endl;
1530 int KOpenSSLProxy::ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a,
int n) {
1531 if (K_ASN1_BIT_STRING_get_bit)
return (K_ASN1_BIT_STRING_get_bit)(a,n);
1532 kdWarning() <<
"ANS1_BIT_STRING_get_bit not defined!" << endl;
1537 PKCS7 *KOpenSSLProxy::PKCS7_new(
void) {
1538 if (K_PKCS7_new)
return (K_PKCS7_new)();
1539 kdWarning() <<
"PKCS7_new not defined!" << endl;
1544 void KOpenSSLProxy::PKCS7_free(PKCS7 *a) {
1545 if (K_PKCS7_free) (K_PKCS7_free)(a);
1546 else kdWarning() <<
"PKCS7_free not defined!" << endl;
1550 void KOpenSSLProxy::PKCS7_content_free(PKCS7 *a) {
1551 if (K_PKCS7_content_free) (K_PKCS7_content_free)(a);
1552 else kdWarning() <<
"PKCS7_content_free not defined!" << endl;
1556 int KOpenSSLProxy::i2d_PKCS7(PKCS7 *a,
unsigned char **pp) {
1557 if (K_i2d_PKCS7)
return (K_i2d_PKCS7)(a,pp);
1558 kdWarning() <<
"i2d_PKCS7 not defined!" << endl;
1563 PKCS7 *KOpenSSLProxy::d2i_PKCS7(PKCS7 **a,
unsigned char **pp,
long length) {
1564 if (K_d2i_PKCS7)
return (K_d2i_PKCS7)(a,pp,length);
1565 kdWarning() <<
"d2i_PKCS7 not defined!" << endl;
1570 int KOpenSSLProxy::i2d_PKCS7_fp(FILE *fp,PKCS7 *p7) {
1571 if (K_i2d_PKCS7_fp)
return (K_i2d_PKCS7_fp)(fp,p7);
1572 kdWarning() <<
"i2d_PKCS7_fd not defined!" << endl;
1577 PKCS7 *KOpenSSLProxy::d2i_PKCS7_fp(FILE *fp,PKCS7 **p7) {
1578 if (K_d2i_PKCS7_fp)
return (K_d2i_PKCS7_fp)(fp,p7);
1579 kdWarning() <<
"d2i_PKCS7_fp not defined!" << endl;
1584 int KOpenSSLProxy::i2d_PKCS7_bio(BIO *bp,PKCS7 *p7) {
1585 if (K_i2d_PKCS7_bio)
return (K_i2d_PKCS7_bio)(bp, p7);
1586 kdWarning() <<
"i2d_PKCS7_bio not defined!" << endl;
1591 PKCS7 *KOpenSSLProxy::d2i_PKCS7_bio(BIO *bp,PKCS7 **p7) {
1592 if (K_d2i_PKCS7_bio)
return (K_d2i_PKCS7_bio)(bp, p7);
1593 kdWarning() <<
"d2i_PKCS7_bio not defined!" << endl;
1598 PKCS7 *KOpenSSLProxy::PKCS7_dup(PKCS7 *p7) {
1599 if (K_PKCS7_dup)
return (K_PKCS7_dup)(p7);
1600 kdWarning() <<
"PKCS7_dup not defined!" << endl;
1605 PKCS7 *KOpenSSLProxy::PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
1606 BIO *data,
int flags) {
1607 if (K_PKCS7_sign)
return (K_PKCS7_sign)(signcert,pkey,certs,data,flags);
1608 kdWarning() <<
"PKCS7_sign not defined!" << endl;
1613 int KOpenSSLProxy::PKCS7_verify(PKCS7* p, STACK_OF(X509)* st, X509_STORE* s, BIO* in, BIO *out,
int flags) {
1614 if (K_PKCS7_verify)
return (K_PKCS7_verify)(p,st,s,in,out,flags);
1615 kdWarning() <<
"PKCS7_verify not defined!" << endl;
1620 STACK_OF(X509) *KOpenSSLProxy::PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs,
int flags) {
1621 if (K_PKCS7_get0_signers)
return (K_PKCS7_get0_signers)(p7,certs,flags);
1622 kdWarning() <<
"PKCS7_get0_signers not defined!" << endl;
1627 PKCS7 *KOpenSSLProxy::PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, EVP_CIPHER *cipher,
1629 if (K_PKCS7_encrypt)
return (K_PKCS7_encrypt)(certs,in,cipher,flags);
1630 kdWarning() <<
"PKCS7_encrypt not defined!" << endl;
1635 int KOpenSSLProxy::PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data,
int flags) {
1636 if (K_PKCS7_decrypt)
return (K_PKCS7_decrypt)(p7,pkey,cert,data,flags);
1637 kdWarning() <<
"PKCS7_decrypt not defined!" << endl;
1642 STACK_OF(X509_NAME) *KOpenSSLProxy::SSL_load_client_CA_file(
const char *file) {
1643 if (K_SSL_load_client_CA_file)
return (K_SSL_load_client_CA_file)(file);
1644 kdWarning() <<
"SSL_load_client_CA_file not defined!" << endl;
1649 STACK_OF(X509_INFO) *KOpenSSLProxy::PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb,
void *u) {
1650 if (K_PEM_X509_INFO_read)
return (K_PEM_X509_INFO_read)(fp,sk,cb,u);
1651 kdWarning() <<
"PEM_X509_INFO_read not defined!" << endl;
1656 X509 *KOpenSSLProxy::X509_d2i_fp(FILE *out, X509** buf) {
1657 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)));
1658 kdWarning() <<
"X509_d2i_fp not defined!" << endl;
1663 int KOpenSSLProxy::SSL_peek(SSL *ssl,
void *buf,
int num) {
1664 if (K_SSL_peek)
return (K_SSL_peek)(ssl,buf,num);
1665 kdWarning() <<
"SSL_peek not defined!" << endl;
1670 const char *KOpenSSLProxy::RAND_file_name(
char *buf,
size_t num) {
1671 if (K_RAND_file_name)
return (K_RAND_file_name)(buf, num);
1672 kdWarning() <<
"RAND_file_name not defined!" << endl;
1677 int KOpenSSLProxy::RAND_load_file(
const char *filename,
long max_bytes) {
1678 if (K_RAND_load_file)
return (K_RAND_load_file)(filename, max_bytes);
1679 kdWarning() <<
"REND_load_file not defined!" << endl;
1684 int KOpenSSLProxy::RAND_write_file(
const char *filename) {
1685 if (K_RAND_write_file)
return (K_RAND_write_file)(filename);
1686 kdWarning() <<
"RAND_write_file not defined!" << endl;
1691 int KOpenSSLProxy::X509_PURPOSE_get_count() {
1692 if (K_X509_PURPOSE_get_count)
return (K_X509_PURPOSE_get_count)();
1693 kdWarning() <<
"X509_PURPOSE_get_count not defined!" << endl;
1698 int KOpenSSLProxy::X509_PURPOSE_get_id(X509_PURPOSE *p) {
1699 if (K_X509_PURPOSE_get_id)
return (K_X509_PURPOSE_get_id)(p);
1700 kdWarning() <<
"X509_PURPOSE_get_id not defined!" << endl;
1705 int KOpenSSLProxy::X509_check_purpose(X509 *x,
int id,
int ca) {
1706 if (K_X509_check_purpose)
return (K_X509_check_purpose)(x, id, ca);
1707 kdWarning() <<
"X509_check_purpose not defined!" << endl;
1712 X509_PURPOSE *KOpenSSLProxy::X509_PURPOSE_get0(
int idx) {
1713 if (K_X509_PURPOSE_get0)
return (K_X509_PURPOSE_get0)(idx);
1714 kdWarning() <<
"X509_PURPOSE_get0 not defined!" << endl;
1719 int KOpenSSLProxy::EVP_PKEY_assign(EVP_PKEY *pkey,
int type,
char *key) {
1720 if (K_EVP_PKEY_assign)
return (K_EVP_PKEY_assign)(pkey, type, key);
1721 kdWarning() <<
"EVP_PKEY_assign not defined!" << endl;
1726 int KOpenSSLProxy::X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey) {
1727 if (K_X509_REQ_set_pubkey)
return (K_X509_REQ_set_pubkey)(x, pkey);
1728 kdWarning() <<
"X509_REQ_set_pubkey not defined!" << endl;
1733 void KOpenSSLProxy::RSA_get0_key(
const RSA *r,
1734 const BIGNUM **n,
const BIGNUM **e,
const BIGNUM **d) {
1735 if (K_RSA_get0_key) {
1736 (K_RSA_get0_key)(r, n, e, d);
1739 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1746 kdWarning() <<
"REG_get0_key not defined!" << endl;
1750 RSA* KOpenSSLProxy::RSA_generate_key(
int bits,
unsigned long e,
void
1751 (*callback)(
int,
int,
void *),
void *cb_arg) {
1752 if (K_RSA_generate_key)
return (K_RSA_generate_key)(bits, e, callback, cb_arg);
1753 kdWarning() <<
"RSA_generate_key not defined!" << endl;
1758 void KOpenSSLProxy::DSA_get0_pqg(
const DSA *d,
1759 const BIGNUM **p,
const BIGNUM **q,
const BIGNUM **g) {
1760 if (K_DSA_get0_pqg) {
1761 (K_DSA_get0_pqg)(d, p, q, g);
1764 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1771 kdWarning() <<
"DSA_get0_pqg not defined!" << endl;
1775 void KOpenSSLProxy::DSA_get0_key(
const DSA *d,
1776 const BIGNUM **pub_key,
const BIGNUM **priv_key) {
1777 if (K_DSA_get0_key) {
1778 (K_DSA_get0_key)(d, pub_key, priv_key);
1781 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1783 if (pub_key) *pub_key = d->pub_key;
1784 if (priv_key) *priv_key = d->priv_key;
1787 kdWarning() <<
"DSA_get0_key not defined!" << endl;
1791 STACK *KOpenSSLProxy::X509_get1_email(X509 *x) {
1792 if (K_X509_get1_email)
return (K_X509_get1_email)(x);
1793 kdWarning() <<
"X509_get1_email not defined!" << endl;
1797 void KOpenSSLProxy::X509_email_free(STACK *sk) {
1798 if (K_X509_email_free) (K_X509_email_free)(sk);
1799 else kdWarning() <<
"X509_email_free not defined!" << endl;
1802 EVP_CIPHER *KOpenSSLProxy::EVP_des_ede3_cbc() {
1803 if (K_EVP_des_ede3_cbc)
return (K_EVP_des_ede3_cbc)();
1804 kdWarning() <<
"EVM_des_ede3_cbc not defined!" << endl;
1808 EVP_CIPHER *KOpenSSLProxy::EVP_des_cbc() {
1809 if (K_EVP_des_cbc)
return (K_EVP_des_cbc)();
1810 kdWarning() <<
"EVP_des_cbc not defined!" << endl;
1814 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_cbc() {
1815 if (K_EVP_rc2_cbc)
return (K_EVP_rc2_cbc)();
1816 kdWarning() <<
"EVP_rc2_cbc not defined!" << endl;
1820 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_64_cbc() {
1821 if (K_EVP_rc2_64_cbc)
return (K_EVP_rc2_64_cbc)();
1822 kdWarning() <<
"EVP_rc2_64_cbc not defined!" << endl;
1826 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_40_cbc() {
1827 if (K_EVP_rc2_40_cbc)
return (K_EVP_rc2_40_cbc)();
1828 kdWarning() <<
"EVP_rc2_40_cbc not defined!" << endl;
1832 int KOpenSSLProxy::i2d_X509_REQ_fp(FILE *fp, X509_REQ *x) {
1833 if (K_i2d_X509_REQ_fp)
return (K_i2d_X509_REQ_fp)(fp,x);
1834 kdWarning() <<
"i2d_X509_REQ_fp not defined!" << endl;
1839 void KOpenSSLProxy::ERR_clear_error() {
1840 if (K_ERR_clear_error) (K_ERR_clear_error)();
1841 else kdWarning() <<
"ERR_clear_error not defined!" << endl;
1845 unsigned long KOpenSSLProxy::ERR_get_error() {
1846 if (K_ERR_get_error)
return (K_ERR_get_error)();
1847 kdWarning() <<
"ERR_get_error not defined!" << endl;
1852 void KOpenSSLProxy::ERR_print_errors_fp(FILE* fp) {
1853 if (K_ERR_print_errors_fp) (K_ERR_print_errors_fp)(fp);
1854 else kdWarning() <<
"ERR_print_errors_fp not defined!" << endl;
1858 SSL_SESSION *KOpenSSLProxy::SSL_get1_session(SSL *ssl) {
1859 if (K_SSL_get1_session)
return (K_SSL_get1_session)(ssl);
1860 kdWarning() <<
"SSL_get1_session not defined!" << endl;
1865 void KOpenSSLProxy::SSL_SESSION_free(SSL_SESSION *session) {
1866 if (K_SSL_SESSION_free) (K_SSL_SESSION_free)(session);
1867 else kdWarning() <<
"SSL_SESSION_free not defined!" << endl;
1871 int KOpenSSLProxy::SSL_set_session(SSL *ssl, SSL_SESSION *session) {
1872 if (K_SSL_set_session)
return (K_SSL_set_session)(ssl, session);
1873 kdWarning() <<
"SSL_set_session not defined!" << endl;
1878 SSL_SESSION *KOpenSSLProxy::d2i_SSL_SESSION(SSL_SESSION **a,
unsigned char **pp,
long length) {
1879 if (K_d2i_SSL_SESSION)
return (K_d2i_SSL_SESSION)(a, pp, length);
1880 kdWarning() <<
"d2i_SSL_SESSION not defined!" << endl;
1885 int KOpenSSLProxy::i2d_SSL_SESSION(SSL_SESSION *in,
unsigned char **pp) {
1886 if (K_i2d_SSL_SESSION)
return (K_i2d_SSL_SESSION)(in, pp);
1887 kdWarning() <<
"i2d_SSL_SESSION not defined!" << endl;
1892 int KOpenSSLProxy::i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *p) {
1893 if (K_i2d_PrivateKey_fp)
return (K_i2d_PrivateKey_fp)(fp, p);
1894 kdWarning() <<
"i2d_PrivateKey not defined!" << endl;
1899 int KOpenSSLProxy::i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *p,
const EVP_CIPHER *c,
char *k,
int klen, pem_password_cb *cb,
void *u) {
1900 if (K_i2d_PKCS8PrivateKey_fp)
return (K_i2d_PKCS8PrivateKey_fp)(fp, p, c, k, klen, cb, u);
1901 kdWarning() <<
"i2d_PKCS8PrivateKey_fp not defined!" << endl;
1906 void KOpenSSLProxy::RSA_free(RSA *rsa) {
1907 if (K_RSA_free) (K_RSA_free)(rsa);
1908 else kdWarning() <<
"RSA_free not defined!" << endl;
1912 EVP_CIPHER *KOpenSSLProxy::EVP_bf_cbc() {
1913 if (K_EVP_bf_cbc)
return (K_EVP_bf_cbc)();
1914 kdWarning() <<
"EVP_bf_cbc not defined!" << endl;
1919 int KOpenSSLProxy::X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey,
const EVP_MD *md) {
1920 if (K_X509_REQ_sign)
return (K_X509_REQ_sign)(x, pkey, md);
1921 kdWarning() <<
"X509_REQ_sign not defined!" << endl;
1926 int KOpenSSLProxy::X509_NAME_add_entry_by_txt(X509_NAME *name,
char *field,
1927 int type,
unsigned char *bytes,
int len,
int loc,
int set) {
1928 if (K_X509_NAME_add_entry_by_txt)
return (K_X509_NAME_add_entry_by_txt)(name, field, type, bytes, len, loc, set);
1929 kdWarning() <<
"X509_NAME_add_entry not defined!" << endl;
1934 X509_NAME *KOpenSSLProxy::X509_NAME_new() {
1935 if (K_X509_NAME_new)
return (K_X509_NAME_new)();
1936 kdWarning() <<
"X509_NAME_new not defined!" << endl;
1941 int KOpenSSLProxy::X509_REQ_set_subject_name(X509_REQ *req,X509_NAME *name) {
1942 if (K_X509_REQ_set_subject_name)
return (K_X509_REQ_set_subject_name)(req, name);
1943 kdWarning() <<
"X509_REQ_set_subject_name not defined!" << endl;
1948 unsigned char *KOpenSSLProxy::ASN1_STRING_data(ASN1_STRING *x) {
1949 if (K_ASN1_STRING_data)
return (K_ASN1_STRING_data)(x);
1950 kdWarning() <<
"ASN1_STRING_data not defined!" << endl;
1954 int KOpenSSLProxy::ASN1_STRING_length(ASN1_STRING *x) {
1955 if (K_ASN1_STRING_length)
return (K_ASN1_STRING_length)(x);
1956 kdWarning() <<
"ASN1_STRING_length not defined!" << endl;
1960 STACK_OF(SSL_CIPHER) *KOpenSSLProxy::SSL_get_ciphers(
const SSL* ssl) {
1961 if (K_SSL_get_ciphers)
return (K_SSL_get_ciphers)(ssl);
1962 kdWarning() <<
"SSL_get_ciphers not defined!" << endl;
1966 const ASN1_TIME* KOpenSSLProxy::X509_CRL_get0_lastUpdate(
const X509_CRL *crl) {
1967 if (K_X509_CRL_get0_lastUpdate)
return (K_X509_CRL_get0_lastUpdate)(crl);
1968 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1969 return X509_CRL_get_lastUpdate(crl);
1971 kdWarning() <<
"X509_CRL_get_lastUpdate not defined!" << endl;
1975 const ASN1_TIME* KOpenSSLProxy::X509_CRL_get0_nextUpdate(
const X509_CRL *crl) {
1976 if (K_X509_CRL_get0_nextUpdate)
return (K_X509_CRL_get0_nextUpdate)(crl);
1977 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1978 return X509_CRL_get_nextUpdate(crl);
1980 kdWarning() <<
"X509_CRL_get_nextUpdate not defined!" << endl;
1984 X509* KOpenSSLProxy::X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx) {
1985 if (K_X509_STORE_CTX_get_current_cert)
return (K_X509_STORE_CTX_get_current_cert)(ctx);
1986 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1987 return ctx->current_cert;
1989 kdWarning() <<
"X509_STORE_CTX_get_current_cert not defined!" << endl;
1993 int KOpenSSLProxy::X509_STORE_CTX_get_error(X509_STORE_CTX *ctx) {
1994 if (K_X509_STORE_CTX_get_error)
return (K_X509_STORE_CTX_get_error)(ctx);
1995 #if OPENSSL_VERSION_NUMBER < 0x10100000L
1998 kdWarning() <<
"X509k_STORE_CTX_get_error not defined!" << endl;
2002 int KOpenSSLProxy::X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx) {
2003 if (K_X509_STORE_CTX_get_error_depth)
return (K_X509_STORE_CTX_get_error_depth)(ctx);
2004 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2005 return ctx->error_depth;
2007 kdWarning() <<
"X509_STORE_CTX_get_error_depth not defined!" << endl;
2011 void KOpenSSLProxy::X509_STORE_CTX_set_error(X509_STORE_CTX *ctx,
int s) {
2012 if (K_X509_STORE_CTX_set_error) {
2013 (K_X509_STORE_CTX_set_error)(ctx, s);
2016 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2020 kdWarning() <<
"X509_STORE_CTX_set_error not defined!" << endl;
2023 void KOpenSSLProxy::X509_STORE_set_verify_cb(X509_STORE *ctx,
2024 X509_STORE_CTX_verify_cb verify_cb) {
2025 if (K_X509_STORE_set_verify_cb) {
2026 (K_X509_STORE_set_verify_cb)(ctx, verify_cb);
2029 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2030 X509_STORE_set_verify_cb_func(ctx, verify_cb);
2033 kdWarning() <<
"X590_STORE_set_verify_cb not defined!" << endl;
2036 STACK_OF(X509_OBJECT)* KOpenSSLProxy::X509_STORE_get0_objects(X509_STORE *v) {
2037 if (K_X509_STORE_get0_objects)
return (K_X509_STORE_get0_objects)(v);
2038 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2041 kdWarning() <<
"X509_STORE_get0_objects not defined!" << endl;
2045 X509_LOOKUP_TYPE KOpenSSLProxy::X509_OBJECT_get_type(
const X509_OBJECT *a) {
2046 if (K_X509_OBJECT_get_type)
return (K_X509_OBJECT_get_type)(a);
2047 #if OPENSSL_VERSION_NUMBER < 0x10100000L
2050 kdWarning() <<
"X509_OBJECT_get_type not defined!" << endl;
2051 #if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
2052 return X509_LU_NONE;
2058 X509* KOpenSSLProxy::X509_OBJECT_get0_X509(
const X509_OBJECT *a) {
2059 if (K_X509_OBJECT_get0_X509)
return (K_X509_OBJECT_get0_X509)(a);
2060 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
2061 return a->data.x509;
2063 kdWarning() <<
"X509_OBJECT_get0_X509 not defined!" << endl;
2068 ASN1_TIME* KOpenSSLProxy::X509_getm_notAfter(
const X509 *x) {
2069 if (K_X509_getm_notAfter)
return (K_X509_getm_notAfter)(x);
2070 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
2071 return X509_get_notAfter(x);
2073 kdWarning() <<
"X509_get_notAfter not defined!" << endl;
2077 ASN1_TIME* KOpenSSLProxy::X509_getm_notBefore(
const X509 *x) {
2078 if (K_X509_getm_notBefore)
return (K_X509_getm_notBefore)(x);
2079 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
2080 return X509_get_notBefore(x);
2082 kdWarning() <<
"X509_get_notBefore not defined!" << endl;
2087 STACK* KOpenSSLProxy::sk_dup(
const STACK *s) {
2088 return OPENSSL_sk_dup(s);
2091 void KOpenSSLProxy::sk_free(STACK *s) {
2095 STACK* KOpenSSLProxy::sk_new(
int (*cmp)()) {
2096 return OPENSSL_sk_new(cmp);
2099 int KOpenSSLProxy::sk_num(STACK *s) {
2100 return OPENSSL_sk_num(s);
2103 char* KOpenSSLProxy::sk_pop(STACK *s) {
2104 return OPENSSL_sk_pop(s);
2107 int KOpenSSLProxy::sk_push(STACK *s,
char *d) {
2108 return OPENSSL_sk_push(s, d);
2111 char* KOpenSSLProxy::sk_value(STACK *s,
int n) {
2112 return OPENSSL_sk_value(s, n);
2115 void KOpenSSLProxy::X509_STORE_CTX_set_chain(X509_STORE_CTX *v, STACK_OF(X509)* x) {
2116 X509_STORE_CTX_set0_untrusted(v, x);
2119 SSL_METHOD* KOpenSSLProxy::SSLv23_client_method() {
2120 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.