File indexing completed on 2024-05-05 16:10:20
0001 /* This file is part of the KDE libraries 0002 Copyright (C) 2001-2003 George Staikos <staikos@kde.org> 0003 0004 This library is free software; you can redistribute it and/or 0005 modify it under the terms of the GNU Library General Public 0006 License version 2 as published by the Free Software Foundation. 0007 0008 This library is distributed in the hope that it will be useful, 0009 but WITHOUT ANY WARRANTY; without even the implied warranty of 0010 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 0011 Library General Public License for more details. 0012 0013 You should have received a copy of the GNU Library General Public License 0014 along with this library; see the file COPYING.LIB. If not, write to 0015 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 0016 Boston, MA 02110-1301, USA. 0017 */ 0018 0019 #include "kopenssl.h" 0020 0021 0022 #if KSSL_HAVE_SSL 0023 #include <openssl/opensslv.h> 0024 #endif 0025 0026 #include <kconfig.h> 0027 #include <kconfiggroup.h> 0028 #include <QCoreApplication> 0029 #include <QFile> 0030 #include <QLibrary> 0031 #include <QRegExp> 0032 0033 extern "C" { 0034 #if KSSL_HAVE_SSL 0035 static int (*K_SSL_connect)(SSL *) = nullptr; 0036 static int (*K_SSL_accept)(SSL *) = nullptr; 0037 static int (*K_SSL_read)(SSL *, void *, int) = nullptr; 0038 static int (*K_SSL_write)(SSL *, const void *, int) = nullptr; 0039 static SSL *(*K_SSL_new)(SSL_CTX *) = nullptr; 0040 static void (*K_SSL_free)(SSL *) = nullptr; 0041 static int (*K_SSL_shutdown)(SSL *) = nullptr; 0042 static SSL_CTX *(*K_SSL_CTX_new)(SSL_METHOD *) = nullptr; 0043 static void (*K_SSL_CTX_free)(SSL_CTX *) = nullptr; 0044 static int (*K_SSL_set_fd)(SSL *, int) = nullptr; 0045 static int (*K_SSL_pending)(SSL *) = nullptr; 0046 static int (*K_SSL_peek)(SSL *, void *, int) = nullptr; 0047 static int (*K_SSL_CTX_set_cipher_list)(SSL_CTX *, const char *) = nullptr; 0048 static void (*K_SSL_CTX_set_verify)(SSL_CTX *, int, 0049 int (*)(int, X509_STORE_CTX *)) = nullptr; 0050 static int (*K_SSL_use_certificate)(SSL *, X509 *) = nullptr; 0051 static SSL_CIPHER *(*K_SSL_get_current_cipher)(SSL *) = nullptr; 0052 static long(*K_SSL_ctrl)(SSL *, int, long, char *) = nullptr; 0053 static int (*K_RAND_egd)(const char *) = nullptr; 0054 static const char *(*K_RAND_file_name)(char *, size_t) = nullptr; 0055 static int (*K_RAND_load_file)(const char *, long) = nullptr; 0056 static int (*K_RAND_write_file)(const char *) = nullptr; 0057 static SSL_METHOD *(*K_TLSv1_client_method)() = nullptr; 0058 static SSL_METHOD *(*K_SSLv23_client_method)() = nullptr; 0059 static X509 *(*K_SSL_get_peer_certificate)(SSL *) = nullptr; 0060 static int (*K_SSL_CIPHER_get_bits)(SSL_CIPHER *, int *) = nullptr; 0061 static char *(*K_SSL_CIPHER_get_version)(SSL_CIPHER *) = nullptr; 0062 static const char *(*K_SSL_CIPHER_get_name)(SSL_CIPHER *) = nullptr; 0063 static char *(*K_SSL_CIPHER_description)(SSL_CIPHER *, char *, int) = nullptr; 0064 static X509 *(*K_d2i_X509)(X509 **, unsigned char **, long) = nullptr; 0065 static int (*K_i2d_X509)(X509 *, unsigned char **) = nullptr; 0066 static int (*K_X509_cmp)(X509 *, X509 *) = nullptr; 0067 static void (*K_X509_STORE_CTX_free)(X509_STORE_CTX *) = nullptr; 0068 static int (*K_X509_verify_cert)(X509_STORE_CTX *) = nullptr; 0069 static X509_STORE_CTX *(*K_X509_STORE_CTX_new)(void) = nullptr; 0070 static void (*K_X509_STORE_free)(X509_STORE *) = nullptr; 0071 static X509_STORE *(*K_X509_STORE_new)(void) = nullptr; 0072 static void (*K_X509_free)(X509 *) = nullptr; 0073 static char *(*K_X509_NAME_oneline)(X509_NAME *, char *, int) = nullptr; 0074 static X509_NAME *(*K_X509_get_subject_name)(X509 *) = nullptr; 0075 static X509_NAME *(*K_X509_get_issuer_name)(X509 *) = nullptr; 0076 static X509_LOOKUP *(*K_X509_STORE_add_lookup)(X509_STORE *, X509_LOOKUP_METHOD *) = nullptr; 0077 static X509_LOOKUP_METHOD *(*K_X509_LOOKUP_file)(void) = nullptr; 0078 static void (*K_X509_LOOKUP_free)(X509_LOOKUP *) = nullptr; 0079 static int (*K_X509_LOOKUP_ctrl)(X509_LOOKUP *, int, const char *, long, char **) = nullptr; 0080 static void (*K_X509_STORE_CTX_init)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *) = nullptr; 0081 static void (*K_CRYPTO_free)(void *) = nullptr; 0082 static X509 *(*K_X509_dup)(X509 *) = nullptr; 0083 static BIO_METHOD *(*K_BIO_s_mem)(void) = nullptr; 0084 static BIO *(*K_BIO_new)(BIO_METHOD *) = nullptr; 0085 static BIO *(*K_BIO_new_fp)(FILE *, int) = nullptr; 0086 static BIO *(*K_BIO_new_mem_buf)(void *, int) = nullptr; 0087 static int (*K_BIO_free)(BIO *) = nullptr; 0088 static long(*K_BIO_ctrl)(BIO *, int, long, void *) = nullptr; 0089 static int (*K_BIO_write)(BIO *b, const void *data, int len) = nullptr; 0090 static int (*K_PEM_ASN1_write_bio)(int (*)(), const char *, BIO *, char *, 0091 const EVP_CIPHER *, unsigned char *, int, 0092 pem_password_cb *, void *) = nullptr; 0093 static int (*K_ASN1_item_i2d_fp)(ASN1_ITEM *, FILE *, unsigned char *) = nullptr; 0094 static ASN1_ITEM *K_NETSCAPE_X509_it = nullptr; 0095 static int (*K_X509_print_fp)(FILE *, X509 *) = nullptr; 0096 static int (*K_i2d_PKCS12)(PKCS12 *, unsigned char **) = nullptr; 0097 static int (*K_i2d_PKCS12_fp)(FILE *, PKCS12 *) = nullptr; 0098 static int (*K_PKCS12_newpass)(PKCS12 *, char *, char *) = nullptr; 0099 static PKCS12 *(*K_d2i_PKCS12_fp)(FILE *, PKCS12 **) = nullptr; 0100 static PKCS12 *(*K_PKCS12_new)(void) = nullptr; 0101 static void (*K_PKCS12_free)(PKCS12 *) = nullptr; 0102 static int (*K_PKCS12_parse)(PKCS12 *, const char *, EVP_PKEY **, 0103 X509 **, STACK_OF(X509) **) = nullptr; 0104 static void (*K_EVP_PKEY_free)(EVP_PKEY *) = nullptr; 0105 static EVP_PKEY *(*K_EVP_PKEY_new)() = nullptr; 0106 static void (*K_X509_REQ_free)(X509_REQ *) = nullptr; 0107 static X509_REQ *(*K_X509_REQ_new)() = nullptr; 0108 static int (*K_SSL_CTX_use_PrivateKey)(SSL_CTX *, EVP_PKEY *) = nullptr; 0109 static int (*K_SSL_CTX_use_certificate)(SSL_CTX *, X509 *) = nullptr; 0110 static int (*K_SSL_get_error)(SSL *, int) = nullptr; 0111 static STACK_OF(X509) *(*K_SSL_get_peer_cert_chain)(SSL *) = nullptr; 0112 static void (*K_X509_STORE_CTX_set_chain)(X509_STORE_CTX *, STACK_OF(X509) *) = nullptr; 0113 static void (*K_X509_STORE_CTX_set_purpose)(X509_STORE_CTX *, int) = nullptr; 0114 static void (*K_sk_free)(STACK *) = nullptr; 0115 static int (*K_sk_num)(STACK *) = nullptr; 0116 static char *(*K_sk_pop)(STACK *) = nullptr; 0117 static char *(*K_sk_value)(STACK *, int) = nullptr; 0118 static STACK *(*K_sk_new)(int (*)()) = nullptr; 0119 static int (*K_sk_push)(STACK *, char *) = nullptr; 0120 static STACK *(*K_sk_dup)(STACK *) = nullptr; 0121 static char *(*K_i2s_ASN1_INTEGER)(X509V3_EXT_METHOD *, ASN1_INTEGER *) = nullptr; 0122 static ASN1_INTEGER *(*K_X509_get_serialNumber)(X509 *) = nullptr; 0123 static EVP_PKEY *(*K_X509_get_pubkey)(X509 *) = nullptr; 0124 static int (*K_i2d_PublicKey)(EVP_PKEY *, unsigned char **) = nullptr; 0125 static int (*K_X509_check_private_key)(X509 *, EVP_PKEY *) = nullptr; 0126 static char *(*K_BN_bn2hex)(const BIGNUM *) = nullptr; 0127 static int (*K_X509_digest)(const X509 *, const EVP_MD *, unsigned char *, unsigned int *) = nullptr; 0128 static EVP_MD *(*K_EVP_md5)() = nullptr; 0129 static void (*K_ASN1_INTEGER_free)(ASN1_INTEGER *) = nullptr; 0130 static int (*K_OBJ_obj2nid)(ASN1_OBJECT *) = nullptr; 0131 static const char *(*K_OBJ_nid2ln)(int) = nullptr; 0132 static int (*K_X509_get_ext_count)(X509 *) = nullptr; 0133 static int (*K_X509_get_ext_by_NID)(X509 *, int, int) = nullptr; 0134 static int (*K_X509_get_ext_by_OBJ)(X509 *, ASN1_OBJECT *, int) = nullptr; 0135 static X509_EXTENSION *(*K_X509_get_ext)(X509 *, int loc) = nullptr; 0136 static X509_EXTENSION *(*K_X509_delete_ext)(X509 *, int) = nullptr; 0137 static int (*K_X509_add_ext)(X509 *, X509_EXTENSION *, int) = nullptr; 0138 static void *(*K_X509_get_ext_d2i)(X509 *, int, int *, int *) = nullptr; 0139 static char *(*K_i2s_ASN1_OCTET_STRING)(X509V3_EXT_METHOD *, ASN1_OCTET_STRING *) = nullptr; 0140 static int (*K_ASN1_BIT_STRING_get_bit)(ASN1_BIT_STRING *, int) = nullptr; 0141 static PKCS7 *(*K_PKCS7_new)() = nullptr; 0142 static void (*K_PKCS7_free)(PKCS7 *) = nullptr; 0143 static void (*K_PKCS7_content_free)(PKCS7 *) = nullptr; 0144 static int (*K_i2d_PKCS7)(PKCS7 *, unsigned char **) = nullptr; 0145 static PKCS7 *(*K_d2i_PKCS7)(PKCS7 **, unsigned char **, long) = nullptr; 0146 static int (*K_i2d_PKCS7_fp)(FILE *, PKCS7 *) = nullptr; 0147 static PKCS7 *(*K_d2i_PKCS7_fp)(FILE *, PKCS7 **) = nullptr; 0148 static int (*K_i2d_PKCS7_bio)(BIO *bp, PKCS7 *p7) = nullptr; 0149 static PKCS7 *(*K_d2i_PKCS7_bio)(BIO *bp, PKCS7 **p7) = nullptr; 0150 static PKCS7 *(*K_PKCS7_dup)(PKCS7 *) = nullptr; 0151 static STACK_OF(X509_NAME) *(*K_SSL_load_client_CA_file)(const char *) = nullptr; 0152 static STACK_OF(X509_INFO) *(*K_PEM_X509_INFO_read)(FILE *, STACK_OF(X509_INFO) *, pem_password_cb *, void *) = nullptr; 0153 static char *(*K_ASN1_d2i_fp)(char *(*)(), char *(*)(), FILE *, unsigned char **) = nullptr; 0154 static X509 *(*K_X509_new)() = nullptr; 0155 static int (*K_X509_PURPOSE_get_count)() = nullptr; 0156 static int (*K_X509_PURPOSE_get_id)(X509_PURPOSE *) = nullptr; 0157 static int (*K_X509_check_purpose)(X509 *, int, int) = nullptr; 0158 static X509_PURPOSE *(*K_X509_PURPOSE_get0)(int) = nullptr; 0159 static int (*K_EVP_PKEY_assign)(EVP_PKEY *, int, char *) = nullptr; 0160 static int (*K_X509_REQ_set_pubkey)(X509_REQ *, EVP_PKEY *) = nullptr; 0161 static RSA *(*K_RSA_generate_key)(int, unsigned long, void (*)(int, int, void *), void *) = nullptr; 0162 static int (*K_i2d_X509_REQ_fp)(FILE *, X509_REQ *) = nullptr; 0163 static void (*K_ERR_clear_error)() = nullptr; 0164 static unsigned long(*K_ERR_get_error)() = nullptr; 0165 static void (*K_ERR_print_errors_fp)(FILE *) = nullptr; 0166 static PKCS7 *(*K_PKCS7_sign)(X509 *, EVP_PKEY *, STACK_OF(X509) *, BIO *, int) = nullptr; 0167 static int (*K_PKCS7_verify)(PKCS7 *, STACK_OF(X509) *, X509_STORE *, BIO *, BIO *, int) = nullptr; 0168 static STACK_OF(X509) *(*K_PKCS7_get0_signers)(PKCS7 *, STACK_OF(X509) *, int) = nullptr; 0169 static PKCS7 *(*K_PKCS7_encrypt)(STACK_OF(X509) *, BIO *, EVP_CIPHER *, int) = nullptr; 0170 static int (*K_PKCS7_decrypt)(PKCS7 *, EVP_PKEY *, X509 *, BIO *, int) = nullptr; 0171 static SSL_SESSION *(*K_SSL_get1_session)(SSL *) = nullptr; 0172 static void (*K_SSL_SESSION_free)(SSL_SESSION *) = nullptr; 0173 static int (*K_SSL_set_session)(SSL *, SSL_SESSION *) = nullptr; 0174 static SSL_SESSION *(*K_d2i_SSL_SESSION)(SSL_SESSION **, unsigned char **, long) = nullptr; 0175 static int (*K_i2d_SSL_SESSION)(SSL_SESSION *, unsigned char **) = nullptr; 0176 static STACK *(*K_X509_get1_email)(X509 *x) = nullptr; 0177 static void (*K_X509_email_free)(STACK *sk) = nullptr; 0178 static EVP_CIPHER *(*K_EVP_des_ede3_cbc)() = nullptr; 0179 static EVP_CIPHER *(*K_EVP_des_cbc)() = nullptr; 0180 static EVP_CIPHER *(*K_EVP_rc2_cbc)() = nullptr; 0181 static EVP_CIPHER *(*K_EVP_rc2_64_cbc)() = nullptr; 0182 static EVP_CIPHER *(*K_EVP_rc2_40_cbc)() = nullptr; 0183 static int (*K_i2d_PrivateKey_fp)(FILE *, EVP_PKEY *) = nullptr; 0184 static int (*K_i2d_PKCS8PrivateKey_fp)(FILE *, EVP_PKEY *, const EVP_CIPHER *, char *, int, pem_password_cb *, void *) = nullptr; 0185 static void (*K_RSA_free)(RSA *) = nullptr; 0186 static EVP_CIPHER *(*K_EVP_bf_cbc)() = nullptr; 0187 static int (*K_X509_REQ_sign)(X509_REQ *, EVP_PKEY *, const EVP_MD *) = nullptr; 0188 static int (*K_X509_NAME_add_entry_by_txt)(X509_NAME *, char *, int, unsigned char *, int, int, int) = nullptr; 0189 static X509_NAME *(*K_X509_NAME_new)() = nullptr; 0190 static int (*K_X509_REQ_set_subject_name)(X509_REQ *, X509_NAME *) = nullptr; 0191 static unsigned char *(*K_ASN1_STRING_data)(ASN1_STRING *) = nullptr; 0192 static int (*K_ASN1_STRING_length)(ASN1_STRING *) = nullptr; 0193 static STACK_OF(SSL_CIPHER) *(*K_SSL_get_ciphers)(const SSL *ssl) = nullptr; 0194 0195 #endif 0196 } 0197 0198 class KOpenSSLProxyPrivate 0199 { 0200 public: 0201 KOpenSSLProxyPrivate() 0202 : sslLib(nullptr), cryptoLib(nullptr), ok(false) 0203 {} 0204 0205 QLibrary *sslLib; 0206 QLibrary *cryptoLib; 0207 bool ok; 0208 0209 static KOpenSSLProxy *sSelf; 0210 static void cleanupKOpenSSLProxy() 0211 { 0212 delete KOpenSSLProxyPrivate::sSelf; 0213 } 0214 }; 0215 KOpenSSLProxy *KOpenSSLProxyPrivate::sSelf = nullptr; 0216 0217 bool KOpenSSLProxy::hasLibSSL() const 0218 { 0219 return d->sslLib != nullptr; 0220 } 0221 0222 bool KOpenSSLProxy::hasLibCrypto() const 0223 { 0224 return d->cryptoLib != nullptr; 0225 } 0226 0227 void KOpenSSLProxy::destroy() 0228 { 0229 KOpenSSLProxy *x = KOpenSSLProxyPrivate::sSelf; 0230 KOpenSSLProxyPrivate::sSelf = nullptr; 0231 delete x; 0232 } 0233 0234 #ifdef __OpenBSD__ 0235 #include <QDir> 0236 #include <QString> 0237 #include <QStringList> 0238 0239 static QString findMostRecentLib(QString dir, QString name) 0240 { 0241 // Grab all shared libraries in the directory 0242 QString filter = "lib" + name + ".so.*"; 0243 QDir d(dir, filter); 0244 if (!d.exists()) { 0245 return 0L; 0246 } 0247 QStringList l = d.entryList(); 0248 0249 // Find the best one 0250 int bestmaj = -1; 0251 int bestmin = -1; 0252 QString best = 0L; 0253 // where do we start 0254 uint s = filter.length() - 1; 0255 for (QStringList::iterator it = l.begin(); it != l.end(); ++it) { 0256 QString numberpart = (*it).mid(s); 0257 uint endmaj = numberpart.indexOf('.'); 0258 if (endmaj == -1) { 0259 continue; 0260 } 0261 bool ok; 0262 int maj = numberpart.left(endmaj).toInt(&ok); 0263 if (!ok) { 0264 continue; 0265 } 0266 int min = numberpart.mid(endmaj + 1).toInt(&ok); 0267 if (!ok) { 0268 continue; 0269 } 0270 if (maj > bestmaj || (maj == bestmaj && min > bestmin)) { 0271 bestmaj = maj; 0272 bestmin = min; 0273 best = (*it); 0274 } 0275 } 0276 if (best.isNull()) { 0277 return 0L; 0278 } else { 0279 return dir + '/' + best; 0280 } 0281 } 0282 #endif 0283 0284 KOpenSSLProxy::KOpenSSLProxy() 0285 : d(new KOpenSSLProxyPrivate()) 0286 { 0287 QStringList libpaths, libnamesc, libnamess; 0288 0289 d->cryptoLib = nullptr; 0290 d->sslLib = nullptr; 0291 0292 KConfig cfg("cryptodefaults", KConfig::NoGlobals); 0293 KConfigGroup cg(&cfg, "OpenSSL"); 0294 QString upath = cg.readPathEntry("Path", QString()); 0295 if (!upath.isEmpty()) { 0296 libpaths << upath; 0297 } 0298 0299 #ifdef Q_OS_WIN 0300 d->cryptoLib = new QLibrary("libeay32.dll"); 0301 if (!d->cryptoLib->load()) { 0302 delete d->cryptoLib; 0303 d->cryptoLib = 0; 0304 } 0305 #elif defined(__OpenBSD__) 0306 { 0307 QString libname = findMostRecentLib("/usr/lib" KDELIBSUFF, "crypto"); 0308 if (!libname.isNull()) { 0309 d->cryptoLib = new QLibrary(libname); 0310 d->cryptoLib->setLoadHints(QLibrary::ExportExternalSymbolsHint); 0311 if (!d->cryptoLib->load()) { 0312 delete d->cryptoLib; 0313 d->cryptoLib = 0; 0314 } 0315 } 0316 } 0317 #elif defined(__CYGWIN__) 0318 libpaths << "/usr/bin/" 0319 << ""; 0320 0321 libnamess << "cygssl-0.9.8.dll" 0322 << "cygssl-0.9.7.dll" 0323 << ""; 0324 0325 libnamesc << "cygcrypto-0.9.8.dll" 0326 << "cygcrypto-0.9.7.dll" 0327 << ""; 0328 #else 0329 libpaths 0330 #ifdef _AIX 0331 << "/opt/freeware/lib/" 0332 #endif 0333 << "/usr/lib" KDELIBSUFF "/" 0334 << "/usr/ssl/lib" KDELIBSUFF "/" 0335 << "/usr/local/lib" KDELIBSUFF "/" 0336 << "/usr/local/openssl/lib" KDELIBSUFF "/" 0337 << "/usr/local/ssl/lib" KDELIBSUFF "/" 0338 << "/opt/openssl/lib" KDELIBSUFF "/" 0339 << "/lib" KDELIBSUFF "/" 0340 << ""; 0341 0342 // FIXME: #define here for the various OS types to optimize 0343 libnamess 0344 #ifdef hpux 0345 << "libssl.sl" 0346 #elif defined(_AIX) 0347 << "libssl.a(libssl.so.0)" 0348 #elif defined(__APPLE__) 0349 << "libssl.dylib" 0350 << "libssl.0.9.dylib" 0351 #else 0352 #ifdef SHLIB_VERSION_NUMBER 0353 << "libssl.so." SHLIB_VERSION_NUMBER 0354 #endif 0355 << "libssl.so" 0356 << "libssl.so.0" 0357 #endif 0358 ; 0359 0360 libnamesc 0361 #ifdef hpux 0362 << "libcrypto.sl" 0363 #elif defined(_AIX) 0364 << "libcrypto.a(libcrypto.so.0)" 0365 #elif defined(__APPLE__) 0366 << "libcrypto.dylib" 0367 << "libcrypto.0.9.dylib" 0368 #else 0369 #ifdef SHLIB_VERSION_NUMBER 0370 << "libcrypto.so." SHLIB_VERSION_NUMBER 0371 #endif 0372 << "libcrypto.so" 0373 << "libcrypto.so.0" 0374 #endif 0375 ; 0376 #endif 0377 0378 for (QStringList::const_iterator it = libpaths.constBegin(); 0379 it != libpaths.constEnd(); 0380 ++it) { 0381 for (QStringList::const_iterator shit = libnamesc.constBegin(); 0382 shit != libnamesc.constEnd(); 0383 ++shit) { 0384 QString alib = *it; 0385 if (!alib.isEmpty() && !alib.endsWith('/')) { 0386 alib += '/'; 0387 } 0388 alib += *shit; 0389 // someone knows why this is needed? 0390 QString tmpStr(alib); 0391 tmpStr.remove(QRegExp("\\(.*\\)")); 0392 if (QFile(tmpStr).isReadable()) { 0393 d->cryptoLib = new QLibrary(alib); 0394 d->cryptoLib->setLoadHints(QLibrary::ExportExternalSymbolsHint); 0395 } 0396 if (d->cryptoLib && d->cryptoLib->load()) { 0397 break; 0398 } else { 0399 delete d->cryptoLib; 0400 d->cryptoLib = nullptr; 0401 } 0402 } 0403 if (d->cryptoLib) { 0404 break; 0405 } 0406 } 0407 0408 if (d->cryptoLib) { 0409 #if KSSL_HAVE_SSL 0410 K_X509_free = (void (*)(X509 *)) d->cryptoLib->resolve("X509_free"); 0411 K_RAND_egd = (int (*)(const char *)) d->cryptoLib->resolve("RAND_egd"); 0412 K_RAND_load_file = (int (*)(const char *, long)) d->cryptoLib->resolve("RAND_load_file"); 0413 K_RAND_file_name = (const char *(*)(char *, size_t)) d->cryptoLib->resolve("RAND_file_name"); 0414 K_RAND_write_file = (int (*)(const char *)) d->cryptoLib->resolve("RAND_write_file"); 0415 K_CRYPTO_free = (void (*)(void *)) d->cryptoLib->resolve("CRYPTO_free"); 0416 K_d2i_X509 = (X509 * (*)(X509 **, unsigned char **, long)) d->cryptoLib->resolve("d2i_X509"); 0417 K_i2d_X509 = (int (*)(X509 *, unsigned char **)) d->cryptoLib->resolve("i2d_X509"); 0418 K_X509_cmp = (int (*)(X509 *, X509 *)) d->cryptoLib->resolve("X509_cmp"); 0419 K_X509_STORE_CTX_new = (X509_STORE_CTX * (*)(void)) d->cryptoLib->resolve("X509_STORE_CTX_new"); 0420 K_X509_STORE_CTX_free = (void (*)(X509_STORE_CTX *)) d->cryptoLib->resolve("X509_STORE_CTX_free"); 0421 K_X509_verify_cert = (int (*)(X509_STORE_CTX *)) d->cryptoLib->resolve("X509_verify_cert"); 0422 K_X509_STORE_new = (X509_STORE * (*)(void)) d->cryptoLib->resolve("X509_STORE_new"); 0423 K_X509_STORE_free = (void (*)(X509_STORE *)) d->cryptoLib->resolve("X509_STORE_free"); 0424 K_X509_NAME_oneline = (char *(*)(X509_NAME *, char *, int)) d->cryptoLib->resolve("X509_NAME_oneline"); 0425 K_X509_get_subject_name = (X509_NAME * (*)(X509 *)) d->cryptoLib->resolve("X509_get_subject_name"); 0426 K_X509_get_issuer_name = (X509_NAME * (*)(X509 *)) d->cryptoLib->resolve("X509_get_issuer_name"); 0427 K_X509_STORE_add_lookup = (X509_LOOKUP * (*)(X509_STORE *, X509_LOOKUP_METHOD *)) d->cryptoLib->resolve("X509_STORE_add_lookup"); 0428 K_X509_LOOKUP_file = (X509_LOOKUP_METHOD * (*)(void)) d->cryptoLib->resolve("X509_LOOKUP_file"); 0429 K_X509_LOOKUP_free = (void (*)(X509_LOOKUP *)) d->cryptoLib->resolve("X509_LOOKUP_free"); 0430 K_X509_LOOKUP_ctrl = (int (*)(X509_LOOKUP *, int, const char *, long, char **)) d->cryptoLib->resolve("X509_LOOKUP_ctrl"); 0431 K_X509_STORE_CTX_init = (void (*)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *)) d->cryptoLib->resolve("X509_STORE_CTX_init"); 0432 K_X509_dup = (X509 * (*)(X509 *)) d->cryptoLib->resolve("X509_dup"); 0433 K_BIO_s_mem = (BIO_METHOD * (*)(void)) d->cryptoLib->resolve("BIO_s_mem"); 0434 K_BIO_new = (BIO * (*)(BIO_METHOD *)) d->cryptoLib->resolve("BIO_new"); 0435 K_BIO_new_fp = (BIO * (*)(FILE *, int)) d->cryptoLib->resolve("BIO_new_fp"); 0436 K_BIO_new_mem_buf = (BIO * (*)(void *, int)) d->cryptoLib->resolve("BIO_new_mem_buf"); 0437 K_BIO_free = (int (*)(BIO *)) d->cryptoLib->resolve("BIO_free"); 0438 K_BIO_ctrl = (long(*)(BIO *, int, long, void *)) d->cryptoLib->resolve("BIO_ctrl"); 0439 K_BIO_write = (int (*)(BIO * b, const void *data, int len)) d->cryptoLib->resolve("BIO_write"); 0440 K_PEM_ASN1_write_bio = (int (*)(int (*)(), const char *, BIO *, char *, const EVP_CIPHER *, unsigned char *, int, pem_password_cb *, void *)) d->cryptoLib->resolve("PEM_ASN1_write_bio"); 0441 K_ASN1_item_i2d_fp = (int (*)(ASN1_ITEM *, FILE *, unsigned char *)) 0442 d->cryptoLib->resolve("ASN1_item_i2d_fp"); 0443 K_NETSCAPE_X509_it = (ASN1_ITEM *) d->cryptoLib->resolve("NETSCAPE_X509_it"); 0444 K_X509_print_fp = (int (*)(FILE *, X509 *)) d->cryptoLib->resolve("X509_print_fp"); 0445 K_i2d_PKCS12 = (int (*)(PKCS12 *, unsigned char **)) d->cryptoLib->resolve("i2d_PKCS12"); 0446 K_i2d_PKCS12_fp = (int (*)(FILE *, PKCS12 *)) d->cryptoLib->resolve("i2d_PKCS12_fp"); 0447 K_PKCS12_newpass = (int (*)(PKCS12 *, char *, char *)) d->cryptoLib->resolve("PKCS12_newpass"); 0448 K_d2i_PKCS12_fp = (PKCS12 * (*)(FILE *, PKCS12 **)) d->cryptoLib->resolve("d2i_PKCS12_fp"); 0449 K_PKCS12_new = (PKCS12 * (*)()) d->cryptoLib->resolve("PKCS12_new"); 0450 K_PKCS12_free = (void (*)(PKCS12 *)) d->cryptoLib->resolve("PKCS12_free"); 0451 K_PKCS12_parse = (int (*)(PKCS12 *, const char *, EVP_PKEY **, 0452 X509 **, STACK_OF(X509) **)) d->cryptoLib->resolve("PKCS12_parse"); 0453 K_EVP_PKEY_free = (void (*)(EVP_PKEY *)) d->cryptoLib->resolve("EVP_PKEY_free"); 0454 K_EVP_PKEY_new = (EVP_PKEY * (*)()) d->cryptoLib->resolve("EVP_PKEY_new"); 0455 K_X509_REQ_free = (void (*)(X509_REQ *)) d->cryptoLib->resolve("X509_REQ_free"); 0456 K_X509_REQ_new = (X509_REQ * (*)()) d->cryptoLib->resolve("X509_REQ_new"); 0457 K_X509_STORE_CTX_set_chain = (void (*)(X509_STORE_CTX *, STACK_OF(X509) *)) d->cryptoLib->resolve("X509_STORE_CTX_set_chain"); 0458 K_X509_STORE_CTX_set_purpose = (void (*)(X509_STORE_CTX *, int)) d->cryptoLib->resolve("X509_STORE_CTX_set_purpose"); 0459 K_sk_free = (void (*)(STACK *)) d->cryptoLib->resolve("sk_free"); 0460 K_sk_num = (int (*)(STACK *)) d->cryptoLib->resolve("sk_num"); 0461 K_sk_pop = (char *(*)(STACK *)) d->cryptoLib->resolve("sk_pop"); 0462 K_sk_value = (char *(*)(STACK *, int)) d->cryptoLib->resolve("sk_value"); 0463 K_sk_new = (STACK * (*)(int (*)())) d->cryptoLib->resolve("sk_new"); 0464 K_sk_push = (int (*)(STACK *, char *)) d->cryptoLib->resolve("sk_push"); 0465 K_sk_dup = (STACK * (*)(STACK *)) d->cryptoLib->resolve("sk_dup"); 0466 K_i2s_ASN1_INTEGER = (char *(*)(X509V3_EXT_METHOD *, ASN1_INTEGER *)) d->cryptoLib->resolve("i2s_ASN1_INTEGER"); 0467 K_X509_get_serialNumber = (ASN1_INTEGER * (*)(X509 *)) d->cryptoLib->resolve("X509_get_serialNumber"); 0468 K_X509_get_pubkey = (EVP_PKEY * (*)(X509 *)) d->cryptoLib->resolve("X509_get_pubkey"); 0469 K_i2d_PublicKey = (int (*)(EVP_PKEY *, unsigned char **)) d->cryptoLib->resolve("i2d_PublicKey"); 0470 K_X509_check_private_key = (int (*)(X509 *, EVP_PKEY *)) d->cryptoLib->resolve("X509_check_private_key"); 0471 K_BN_bn2hex = (char *(*)(const BIGNUM *)) d->cryptoLib->resolve("BN_bn2hex"); 0472 K_X509_digest = (int (*)(const X509 *, const EVP_MD *, unsigned char *, unsigned int *)) d->cryptoLib->resolve("X509_digest"); 0473 K_EVP_md5 = (EVP_MD * (*)()) d->cryptoLib->resolve("EVP_md5"); 0474 K_ASN1_INTEGER_free = (void (*)(ASN1_INTEGER *)) d->cryptoLib->resolve("ASN1_INTEGER_free"); 0475 K_OBJ_obj2nid = (int (*)(ASN1_OBJECT *)) d->cryptoLib->resolve("OBJ_obj2nid"); 0476 K_OBJ_nid2ln = (const char *(*)(int)) d->cryptoLib->resolve("OBJ_nid2ln"); 0477 K_X509_get_ext_count = (int (*)(X509 *)) d->cryptoLib->resolve("X509_get_ext_count"); 0478 K_X509_get_ext_by_NID = (int (*)(X509 *, int, int)) d->cryptoLib->resolve("X509_get_ext_by_NID"); 0479 K_X509_get_ext_by_OBJ = (int (*)(X509 *, ASN1_OBJECT *, int)) d->cryptoLib->resolve("X509_get_ext_by_OBJ"); 0480 K_X509_get_ext = (X509_EXTENSION * (*)(X509 *, int)) d->cryptoLib->resolve("X509_get_ext"); 0481 K_X509_delete_ext = (X509_EXTENSION * (*)(X509 *, int)) d->cryptoLib->resolve("X509_delete_ext"); 0482 K_X509_add_ext = (int (*)(X509 *, X509_EXTENSION *, int)) d->cryptoLib->resolve("X509_add_ext"); 0483 K_X509_get_ext_d2i = (void *(*)(X509 *, int, int *, int *)) d->cryptoLib->resolve("X509_get_ext_d2i"); 0484 K_i2s_ASN1_OCTET_STRING = (char *(*)(X509V3_EXT_METHOD *, ASN1_OCTET_STRING *)) d->cryptoLib->resolve("i2s_ASN1_OCTET_STRING"); 0485 K_ASN1_BIT_STRING_get_bit = (int (*)(ASN1_BIT_STRING *, int)) d->cryptoLib->resolve("ASN1_BIT_STRING_get_bit"); 0486 K_PKCS7_new = (PKCS7 * (*)()) d->cryptoLib->resolve("PKCS7_new"); 0487 K_PKCS7_free = (void (*)(PKCS7 *)) d->cryptoLib->resolve("PKCS7_free"); 0488 K_PKCS7_content_free = (void (*)(PKCS7 *)) d->cryptoLib->resolve("PKCS7_content_free"); 0489 K_i2d_PKCS7 = (int (*)(PKCS7 *, unsigned char **)) d->cryptoLib->resolve("i2d_PKCS7"); 0490 K_i2d_PKCS7_fp = (int (*)(FILE *, PKCS7 *)) d->cryptoLib->resolve("i2d_PKCS7_fp"); 0491 K_i2d_PKCS7_bio = (int (*)(BIO * bp, PKCS7 * p7)) d->cryptoLib->resolve("i2d_PKCS7_bio"); 0492 K_d2i_PKCS7 = (PKCS7 * (*)(PKCS7 **, unsigned char **, long)) d->cryptoLib->resolve("d2i_PKCS7"); 0493 K_d2i_PKCS7_fp = (PKCS7 * (*)(FILE *, PKCS7 **)) d->cryptoLib->resolve("d2i_PKCS7_fp"); 0494 K_d2i_PKCS7_bio = (PKCS7 * (*)(BIO * bp, PKCS7 **p7)) d->cryptoLib->resolve("d2i_PKCS7_bio"); 0495 K_PKCS7_dup = (PKCS7 * (*)(PKCS7 *)) d->cryptoLib->resolve("PKCS7_dup"); 0496 K_PKCS7_sign = (PKCS7 * (*)(X509 *, EVP_PKEY *, STACK_OF(X509) *, BIO *, int)) d->cryptoLib->resolve("PKCS7_sign"); 0497 K_PKCS7_verify = (int (*)(PKCS7 *, STACK_OF(X509) *, X509_STORE *, BIO *, BIO *, int)) d->cryptoLib->resolve("PKCS7_verify"); 0498 K_PKCS7_get0_signers = (STACK_OF(X509) * (*)(PKCS7 *, STACK_OF(X509) *, int)) d->cryptoLib->resolve("PKCS7_get0_signers"); 0499 K_PKCS7_encrypt = (PKCS7 * (*)(STACK_OF(X509) *, BIO *, EVP_CIPHER *, int)) d->cryptoLib->resolve("PKCS7_encrypt"); 0500 K_PKCS7_decrypt = (int (*)(PKCS7 *, EVP_PKEY *, X509 *, BIO *, int)) d->cryptoLib->resolve("PKCS7_decrypt"); 0501 K_PEM_X509_INFO_read = (STACK_OF(X509_INFO) * (*)(FILE *, STACK_OF(X509_INFO) *, pem_password_cb *, void *)) d->cryptoLib->resolve("PEM_X509_INFO_read"); 0502 K_ASN1_d2i_fp = (char *(*)(char *(*)(), char *(*)(), FILE *, unsigned char **)) d->cryptoLib->resolve("ASN1_d2i_fp"); 0503 K_X509_new = (X509 * (*)()) d->cryptoLib->resolve("X509_new"); 0504 K_X509_PURPOSE_get_count = (int (*)()) d->cryptoLib->resolve("X509_PURPOSE_get_count"); 0505 K_X509_PURPOSE_get_id = (int (*)(X509_PURPOSE *)) d->cryptoLib->resolve("X509_PURPOSE_get_id"); 0506 K_X509_check_purpose = (int (*)(X509 *, int, int)) d->cryptoLib->resolve("X509_check_purpose"); 0507 K_X509_PURPOSE_get0 = (X509_PURPOSE * (*)(int)) d->cryptoLib->resolve("X509_PURPOSE_get0"); 0508 K_EVP_PKEY_assign = (int (*)(EVP_PKEY *, int, char *)) d->cryptoLib->resolve("EVP_PKEY_assign"); 0509 K_X509_REQ_set_pubkey = (int (*)(X509_REQ *, EVP_PKEY *)) d->cryptoLib->resolve("X509_REQ_set_pubkey"); 0510 K_RSA_generate_key = (RSA * (*)(int, unsigned long, void (*)(int, int, void *), void *)) d->cryptoLib->resolve("RSA_generate_key"); 0511 K_i2d_X509_REQ_fp = (int (*)(FILE *, X509_REQ *)) d->cryptoLib->resolve("i2d_X509_REQ_fp"); 0512 K_ERR_clear_error = (void (*)()) d->cryptoLib->resolve("ERR_clear_error"); 0513 K_ERR_get_error = (unsigned long(*)()) d->cryptoLib->resolve("ERR_get_error"); 0514 K_ERR_print_errors_fp = (void (*)(FILE *)) d->cryptoLib->resolve("ERR_print_errors_fp"); 0515 K_X509_get1_email = (STACK * (*)(X509 * x)) d->cryptoLib->resolve("X509_get1_email"); 0516 K_X509_email_free = (void (*)(STACK * sk)) d->cryptoLib->resolve("X509_email_free"); 0517 K_EVP_des_ede3_cbc = (EVP_CIPHER * (*)()) d->cryptoLib->resolve("EVP_des_ede3_cbc"); 0518 K_EVP_des_cbc = (EVP_CIPHER * (*)()) d->cryptoLib->resolve("EVP_des_cbc"); 0519 K_EVP_rc2_cbc = (EVP_CIPHER * (*)()) d->cryptoLib->resolve("EVP_rc2_cbc"); 0520 K_EVP_rc2_64_cbc = (EVP_CIPHER * (*)()) d->cryptoLib->resolve("EVP_rc2_64_cbc"); 0521 K_EVP_rc2_40_cbc = (EVP_CIPHER * (*)()) d->cryptoLib->resolve("EVP_rc2_40_cbc"); 0522 K_i2d_PrivateKey_fp = (int (*)(FILE *, EVP_PKEY *)) d->cryptoLib->resolve("i2d_PrivateKey_fp"); 0523 K_i2d_PKCS8PrivateKey_fp = (int (*)(FILE *, EVP_PKEY *, const EVP_CIPHER *, char *, int, pem_password_cb *, void *)) d->cryptoLib->resolve("i2d_PKCS8PrivateKey_fp"); 0524 K_RSA_free = (void (*)(RSA *)) d->cryptoLib->resolve("RSA_free"); 0525 K_EVP_bf_cbc = (EVP_CIPHER * (*)()) d->cryptoLib->resolve("EVP_bf_cbc"); 0526 K_X509_REQ_sign = (int (*)(X509_REQ *, EVP_PKEY *, const EVP_MD *)) d->cryptoLib->resolve("X509_REQ_sign"); 0527 K_X509_NAME_add_entry_by_txt = (int (*)(X509_NAME *, char *, int, unsigned char *, int, int, int)) d->cryptoLib->resolve("X509_NAME_add_entry_by_txt"); 0528 K_X509_NAME_new = (X509_NAME * (*)()) d->cryptoLib->resolve("X509_NAME_new"); 0529 K_X509_REQ_set_subject_name = (int (*)(X509_REQ *, X509_NAME *)) d->cryptoLib->resolve("X509_REQ_set_subject_name"); 0530 K_ASN1_STRING_data = (unsigned char *(*)(ASN1_STRING *)) d->cryptoLib->resolve("ASN1_STRING_data"); 0531 K_ASN1_STRING_length = (int (*)(ASN1_STRING *)) d->cryptoLib->resolve("ASN1_STRING_length"); 0532 #endif 0533 } 0534 0535 #ifdef Q_OS_WIN 0536 d->sslLib = new QLibrary("ssleay32.dll"); 0537 if (!d->sslLib->load()) { 0538 delete d->sslLib; 0539 d->sslLib = 0; 0540 } 0541 #elif defined(__OpenBSD__) 0542 { 0543 QString libname = findMostRecentLib("/usr/lib", "ssl"); 0544 if (!libname.isNull()) { 0545 d->sslLib = new QLibrary(libname); 0546 d->sslLib->setLoadHints(QLibrary::ExportExternalSymbolsHint); 0547 if (!d->sslLib->load()) { 0548 delete d->sslLib; 0549 d->sslLib = 0; 0550 } 0551 } 0552 } 0553 #else 0554 for (QStringList::const_iterator it = libpaths.constBegin(); 0555 it != libpaths.constEnd(); 0556 ++it) { 0557 for (QStringList::const_iterator shit = libnamess.constBegin(); 0558 shit != libnamess.constEnd(); 0559 ++shit) { 0560 QString alib = *it; 0561 if (!alib.isEmpty() && !alib.endsWith('/')) { 0562 alib += '/'; 0563 } 0564 alib += *shit; 0565 QString tmpStr(alib); 0566 tmpStr.remove(QRegExp("\\(.*\\)")); 0567 if (QFile(tmpStr).isReadable()) { 0568 d->sslLib = new QLibrary(alib); 0569 d->sslLib->setLoadHints(QLibrary::ExportExternalSymbolsHint); 0570 } 0571 if (d->sslLib && d->sslLib->load()) { 0572 break; 0573 } else { 0574 delete d->sslLib; 0575 d->sslLib = nullptr; 0576 } 0577 } 0578 if (d->sslLib) { 0579 break; 0580 } 0581 } 0582 #endif 0583 0584 if (d->sslLib) { 0585 #if KSSL_HAVE_SSL 0586 // stand back from your monitor and look at this. it's fun! :) 0587 K_SSL_connect = (int (*)(SSL *)) d->sslLib->resolve("SSL_connect"); 0588 K_SSL_accept = (int (*)(SSL *)) d->sslLib->resolve("SSL_accept"); 0589 K_SSL_read = (int (*)(SSL *, void *, int)) d->sslLib->resolve("SSL_read"); 0590 K_SSL_write = (int (*)(SSL *, const void *, int)) 0591 d->sslLib->resolve("SSL_write"); 0592 K_SSL_new = (SSL * (*)(SSL_CTX *)) d->sslLib->resolve("SSL_new"); 0593 K_SSL_free = (void (*)(SSL *)) d->sslLib->resolve("SSL_free"); 0594 K_SSL_shutdown = (int (*)(SSL *)) d->sslLib->resolve("SSL_shutdown"); 0595 K_SSL_CTX_new = (SSL_CTX * (*)(SSL_METHOD *)) d->sslLib->resolve("SSL_CTX_new"); 0596 K_SSL_CTX_free = (void (*)(SSL_CTX *)) d->sslLib->resolve("SSL_CTX_free"); 0597 K_SSL_set_fd = (int (*)(SSL *, int)) d->sslLib->resolve("SSL_set_fd"); 0598 K_SSL_pending = (int (*)(SSL *)) d->sslLib->resolve("SSL_pending"); 0599 K_SSL_CTX_set_cipher_list = (int (*)(SSL_CTX *, const char *)) 0600 d->sslLib->resolve("SSL_CTX_set_cipher_list"); 0601 K_SSL_CTX_set_verify = (void (*)(SSL_CTX *, int, int (*)(int, X509_STORE_CTX *))) d->sslLib->resolve("SSL_CTX_set_verify"); 0602 K_SSL_use_certificate = (int (*)(SSL *, X509 *)) 0603 d->sslLib->resolve("SSL_CTX_use_certificate"); 0604 K_SSL_get_current_cipher = (SSL_CIPHER * (*)(SSL *)) 0605 d->sslLib->resolve("SSL_get_current_cipher"); 0606 K_SSL_ctrl = (long(*)(SSL *, int, long, char *)) 0607 d->sslLib->resolve("SSL_ctrl"); 0608 K_TLSv1_client_method = (SSL_METHOD * (*)()) d->sslLib->resolve("TLSv1_client_method"); 0609 K_SSLv23_client_method = (SSL_METHOD * (*)()) d->sslLib->resolve("SSLv23_client_method"); 0610 K_SSL_get_peer_certificate = (X509 * (*)(SSL *)) d->sslLib->resolve("SSL_get_peer_certificate"); 0611 K_SSL_CIPHER_get_bits = (int (*)(SSL_CIPHER *, int *)) d->sslLib->resolve("SSL_CIPHER_get_bits"); 0612 K_SSL_CIPHER_get_version = (char *(*)(SSL_CIPHER *)) d->sslLib->resolve("SSL_CIPHER_get_version"); 0613 K_SSL_CIPHER_get_name = (const char *(*)(SSL_CIPHER *)) d->sslLib->resolve("SSL_CIPHER_get_name"); 0614 K_SSL_CIPHER_description = (char *(*)(SSL_CIPHER *, char *, int)) d->sslLib->resolve("SSL_CIPHER_description"); 0615 K_SSL_CTX_use_PrivateKey = (int (*)(SSL_CTX *, EVP_PKEY *)) d->sslLib->resolve("SSL_CTX_use_PrivateKey"); 0616 K_SSL_CTX_use_certificate = (int (*)(SSL_CTX *, X509 *)) d->sslLib->resolve("SSL_CTX_use_certificate"); 0617 K_SSL_get_error = (int (*)(SSL *, int)) d->sslLib->resolve("SSL_get_error"); 0618 K_SSL_get_peer_cert_chain = (STACK_OF(X509) * (*)(SSL *)) d->sslLib->resolve("SSL_get_peer_cert_chain"); 0619 K_SSL_load_client_CA_file = (STACK_OF(X509_NAME) * (*)(const char *)) d->sslLib->resolve("SSL_load_client_CA_file"); 0620 K_SSL_peek = (int (*)(SSL *, void *, int)) d->sslLib->resolve("SSL_peek"); 0621 K_SSL_get1_session = (SSL_SESSION * (*)(SSL *)) d->sslLib->resolve("SSL_get1_session"); 0622 K_SSL_SESSION_free = (void (*)(SSL_SESSION *)) d->sslLib->resolve("SSL_SESSION_free"); 0623 K_SSL_set_session = (int (*)(SSL *, SSL_SESSION *)) d->sslLib->resolve("SSL_set_session"); 0624 K_d2i_SSL_SESSION = (SSL_SESSION * (*)(SSL_SESSION **, unsigned char **, long)) d->sslLib->resolve("d2i_SSL_SESSION"); 0625 K_i2d_SSL_SESSION = (int (*)(SSL_SESSION *, unsigned char **)) d->sslLib->resolve("i2d_SSL_SESSION"); 0626 K_SSL_get_ciphers = (STACK_OF(SSL_CIPHER) * (*)(const SSL *)) d->sslLib->resolve("SSL_get_ciphers"); 0627 #endif 0628 0629 // Initialize the library (once only!) 0630 QFunctionPointer x; 0631 x = d->sslLib->resolve("SSL_library_init"); 0632 if (d->cryptoLib) { 0633 if (x) { 0634 ((int (*)())x)(); 0635 } 0636 x = d->cryptoLib->resolve("OpenSSL_add_all_algorithms"); 0637 if (!x) { 0638 x = d->cryptoLib->resolve("OPENSSL_add_all_algorithms"); 0639 } 0640 if (x) { 0641 ((void (*)())x)(); 0642 } else { 0643 x = d->cryptoLib->resolve("OpenSSL_add_all_algorithms_conf"); 0644 if (!x) { 0645 x = d->cryptoLib->resolve("OPENSSL_add_all_algorithms_conf"); 0646 } 0647 if (x) { 0648 ((void (*)())x)(); 0649 } else { 0650 x = d->cryptoLib->resolve("OpenSSL_add_all_algorithms_noconf"); 0651 if (!x) { 0652 x = d->cryptoLib->resolve("OPENSSL_add_all_algorithms_noconf"); 0653 } 0654 if (x) { 0655 ((void (*)())x)(); 0656 } 0657 } 0658 } 0659 x = d->cryptoLib->resolve("OpenSSL_add_all_ciphers"); 0660 if (!x) { 0661 x = d->cryptoLib->resolve("OPENSSL_add_all_ciphers"); 0662 } 0663 if (x) { 0664 ((void (*)())x)(); 0665 } 0666 x = d->cryptoLib->resolve("OpenSSL_add_all_digests"); 0667 if (!x) { 0668 x = d->cryptoLib->resolve("OPENSSL_add_all_digests"); 0669 } 0670 if (x) { 0671 ((void (*)())x)(); 0672 } 0673 } 0674 } 0675 0676 } 0677 0678 KOpenSSLProxy::~KOpenSSLProxy() 0679 { 0680 if (d->sslLib) { 0681 d->sslLib->unload(); 0682 } 0683 if (d->cryptoLib) { 0684 d->cryptoLib->unload(); 0685 } 0686 0687 KOpenSSLProxyPrivate::sSelf = nullptr; 0688 delete d; 0689 } 0690 0691 // FIXME: we should check "ok" and allow this to init the lib if !ok. 0692 0693 KOpenSSLProxy *KOpenSSLProxy::self() 0694 { 0695 #if KSSL_HAVE_SSL 0696 if (!KOpenSSLProxyPrivate::sSelf) { 0697 KOpenSSLProxyPrivate::sSelf = new KOpenSSLProxy(); 0698 qAddPostRoutine(KOpenSSLProxyPrivate::cleanupKOpenSSLProxy); 0699 } 0700 #endif 0701 return KOpenSSLProxyPrivate::sSelf; 0702 } 0703 0704 #if KSSL_HAVE_SSL 0705 0706 int KOpenSSLProxy::SSL_connect(SSL *ssl) 0707 { 0708 if (K_SSL_connect) { 0709 return (K_SSL_connect)(ssl); 0710 } 0711 return -1; 0712 } 0713 0714 int KOpenSSLProxy::SSL_accept(SSL *ssl) 0715 { 0716 if (K_SSL_accept) { 0717 return (K_SSL_accept)(ssl); 0718 } 0719 return -1; 0720 } 0721 0722 int KOpenSSLProxy::SSL_read(SSL *ssl, void *buf, int num) 0723 { 0724 if (K_SSL_read) { 0725 return (K_SSL_read)(ssl, buf, num); 0726 } 0727 return -1; 0728 } 0729 0730 int KOpenSSLProxy::SSL_write(SSL *ssl, const void *buf, int num) 0731 { 0732 if (K_SSL_write) { 0733 return (K_SSL_write)(ssl, buf, num); 0734 } 0735 return -1; 0736 } 0737 0738 SSL *KOpenSSLProxy::SSL_new(SSL_CTX *ctx) 0739 { 0740 if (K_SSL_new) { 0741 return (K_SSL_new)(ctx); 0742 } 0743 return nullptr; 0744 } 0745 0746 void KOpenSSLProxy::SSL_free(SSL *ssl) 0747 { 0748 if (K_SSL_free) { 0749 (K_SSL_free)(ssl); 0750 } 0751 } 0752 0753 int KOpenSSLProxy::SSL_shutdown(SSL *ssl) 0754 { 0755 if (K_SSL_shutdown) { 0756 return (K_SSL_shutdown)(ssl); 0757 } 0758 return -1; 0759 } 0760 0761 SSL_CTX *KOpenSSLProxy::SSL_CTX_new(SSL_METHOD *method) 0762 { 0763 if (K_SSL_CTX_new) { 0764 return (K_SSL_CTX_new)(method); 0765 } 0766 return nullptr; 0767 } 0768 0769 void KOpenSSLProxy::SSL_CTX_free(SSL_CTX *ctx) 0770 { 0771 if (K_SSL_CTX_free) { 0772 (K_SSL_CTX_free)(ctx); 0773 } 0774 } 0775 0776 int KOpenSSLProxy::SSL_set_fd(SSL *ssl, int fd) 0777 { 0778 if (K_SSL_set_fd) { 0779 return (K_SSL_set_fd)(ssl, fd); 0780 } 0781 return -1; 0782 } 0783 0784 int KOpenSSLProxy::SSL_pending(SSL *ssl) 0785 { 0786 if (K_SSL_pending) { 0787 return (K_SSL_pending)(ssl); 0788 } 0789 return -1; 0790 } 0791 0792 int KOpenSSLProxy::SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str) 0793 { 0794 if (K_SSL_CTX_set_cipher_list) { 0795 return (K_SSL_CTX_set_cipher_list)(ctx, str); 0796 } 0797 return -1; 0798 } 0799 0800 void KOpenSSLProxy::SSL_CTX_set_verify(SSL_CTX *ctx, int mode, 0801 int (*verify_callback)(int, X509_STORE_CTX *)) 0802 { 0803 if (K_SSL_CTX_set_verify) { 0804 (K_SSL_CTX_set_verify)(ctx, mode, verify_callback); 0805 } 0806 } 0807 0808 int KOpenSSLProxy::SSL_use_certificate(SSL *ssl, X509 *x) 0809 { 0810 if (K_SSL_use_certificate) { 0811 return (K_SSL_use_certificate)(ssl, x); 0812 } 0813 return -1; 0814 } 0815 0816 SSL_CIPHER *KOpenSSLProxy::SSL_get_current_cipher(SSL *ssl) 0817 { 0818 if (K_SSL_get_current_cipher) { 0819 return (K_SSL_get_current_cipher)(ssl); 0820 } 0821 return nullptr; 0822 } 0823 0824 long KOpenSSLProxy::SSL_ctrl(SSL *ssl, int cmd, long larg, char *parg) 0825 { 0826 if (K_SSL_ctrl) { 0827 return (K_SSL_ctrl)(ssl, cmd, larg, parg); 0828 } 0829 return -1; 0830 } 0831 0832 int KOpenSSLProxy::RAND_egd(const char *path) 0833 { 0834 if (K_RAND_egd) { 0835 return (K_RAND_egd)(path); 0836 } 0837 return -1; 0838 } 0839 0840 SSL_METHOD *KOpenSSLProxy::TLSv1_client_method() 0841 { 0842 if (K_TLSv1_client_method) { 0843 return (K_TLSv1_client_method)(); 0844 } 0845 return nullptr; 0846 } 0847 0848 SSL_METHOD *KOpenSSLProxy::SSLv23_client_method() 0849 { 0850 if (K_SSLv23_client_method) { 0851 return (K_SSLv23_client_method)(); 0852 } 0853 return nullptr; 0854 } 0855 0856 X509 *KOpenSSLProxy::SSL_get_peer_certificate(SSL *s) 0857 { 0858 if (K_SSL_get_peer_certificate) { 0859 return (K_SSL_get_peer_certificate)(s); 0860 } 0861 return nullptr; 0862 } 0863 0864 int KOpenSSLProxy::SSL_CIPHER_get_bits(SSL_CIPHER *c, int *alg_bits) 0865 { 0866 if (K_SSL_CIPHER_get_bits) { 0867 return (K_SSL_CIPHER_get_bits)(c, alg_bits); 0868 } 0869 return -1; 0870 } 0871 0872 char *KOpenSSLProxy::SSL_CIPHER_get_version(SSL_CIPHER *c) 0873 { 0874 if (K_SSL_CIPHER_get_version) { 0875 return (K_SSL_CIPHER_get_version)(c); 0876 } 0877 return nullptr; 0878 } 0879 0880 const char *KOpenSSLProxy::SSL_CIPHER_get_name(SSL_CIPHER *c) 0881 { 0882 if (K_SSL_CIPHER_get_name) { 0883 return (K_SSL_CIPHER_get_name)(c); 0884 } 0885 return nullptr; 0886 } 0887 0888 char *KOpenSSLProxy::SSL_CIPHER_description(SSL_CIPHER *c, char *buf, int size) 0889 { 0890 if (K_SSL_CIPHER_description) { 0891 return (K_SSL_CIPHER_description)(c, buf, size); 0892 } 0893 return nullptr; 0894 } 0895 0896 X509 *KOpenSSLProxy::d2i_X509(X509 **a, unsigned char **pp, long length) 0897 { 0898 if (K_d2i_X509) { 0899 return (K_d2i_X509)(a, pp, length); 0900 } 0901 return nullptr; 0902 } 0903 0904 int KOpenSSLProxy::i2d_X509(X509 *a, unsigned char **pp) 0905 { 0906 if (K_i2d_X509) { 0907 return (K_i2d_X509)(a, pp); 0908 } 0909 return -1; 0910 } 0911 0912 int KOpenSSLProxy::X509_cmp(X509 *a, X509 *b) 0913 { 0914 if (K_X509_cmp) { 0915 return (K_X509_cmp)(a, b); 0916 } 0917 return 0; 0918 } 0919 0920 X509_STORE *KOpenSSLProxy::X509_STORE_new(void) 0921 { 0922 if (K_X509_STORE_new) { 0923 return (K_X509_STORE_new)(); 0924 } 0925 return nullptr; 0926 } 0927 0928 void KOpenSSLProxy::X509_STORE_free(X509_STORE *v) 0929 { 0930 if (K_X509_STORE_free) { 0931 (K_X509_STORE_free)(v); 0932 } 0933 } 0934 0935 X509_STORE_CTX *KOpenSSLProxy::X509_STORE_CTX_new(void) 0936 { 0937 if (K_X509_STORE_CTX_new) { 0938 return (K_X509_STORE_CTX_new)(); 0939 } 0940 return nullptr; 0941 } 0942 0943 void KOpenSSLProxy::X509_STORE_CTX_free(X509_STORE_CTX *ctx) 0944 { 0945 if (K_X509_STORE_CTX_free) { 0946 (K_X509_STORE_CTX_free)(ctx); 0947 } 0948 } 0949 0950 int KOpenSSLProxy::X509_verify_cert(X509_STORE_CTX *ctx) 0951 { 0952 if (K_X509_verify_cert) { 0953 return (K_X509_verify_cert)(ctx); 0954 } 0955 return -1; 0956 } 0957 0958 void KOpenSSLProxy::X509_free(X509 *a) 0959 { 0960 if (K_X509_free) { 0961 (K_X509_free)(a); 0962 } 0963 } 0964 0965 char *KOpenSSLProxy::X509_NAME_oneline(X509_NAME *a, char *buf, int size) 0966 { 0967 if (K_X509_NAME_oneline) { 0968 return (K_X509_NAME_oneline)(a, buf, size); 0969 } 0970 return nullptr; 0971 } 0972 0973 X509_NAME *KOpenSSLProxy::X509_get_subject_name(X509 *a) 0974 { 0975 if (K_X509_get_subject_name) { 0976 return (K_X509_get_subject_name)(a); 0977 } 0978 return nullptr; 0979 } 0980 0981 X509_NAME *KOpenSSLProxy::X509_get_issuer_name(X509 *a) 0982 { 0983 if (K_X509_get_issuer_name) { 0984 return (K_X509_get_issuer_name)(a); 0985 } 0986 return nullptr; 0987 } 0988 0989 X509_LOOKUP *KOpenSSLProxy::X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m) 0990 { 0991 if (K_X509_STORE_add_lookup) { 0992 return (K_X509_STORE_add_lookup)(v, m); 0993 } 0994 return nullptr; 0995 } 0996 0997 X509_LOOKUP_METHOD *KOpenSSLProxy::X509_LOOKUP_file(void) 0998 { 0999 if (K_X509_LOOKUP_file) { 1000 return (K_X509_LOOKUP_file)(); 1001 } 1002 return nullptr; 1003 } 1004 1005 void KOpenSSLProxy::X509_LOOKUP_free(X509_LOOKUP *x) 1006 { 1007 if (K_X509_LOOKUP_free) { 1008 (K_X509_LOOKUP_free)(x); 1009 } 1010 } 1011 1012 int KOpenSSLProxy::X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl, char **ret) 1013 { 1014 if (K_X509_LOOKUP_ctrl) { 1015 return (K_X509_LOOKUP_ctrl)(ctx, cmd, argc, argl, ret); 1016 } 1017 return -1; 1018 } 1019 1020 void KOpenSSLProxy::X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509, STACK_OF(X509) *chain) 1021 { 1022 if (K_X509_STORE_CTX_init) { 1023 (K_X509_STORE_CTX_init)(ctx, store, x509, chain); 1024 } 1025 } 1026 1027 void KOpenSSLProxy::CRYPTO_free(void *x) 1028 { 1029 if (K_CRYPTO_free) { 1030 (K_CRYPTO_free)(x); 1031 } 1032 } 1033 1034 X509 *KOpenSSLProxy::X509_dup(X509 *x509) 1035 { 1036 if (K_X509_dup) { 1037 return (K_X509_dup)(x509); 1038 } 1039 return nullptr; 1040 } 1041 1042 BIO *KOpenSSLProxy::BIO_new(BIO_METHOD *type) 1043 { 1044 if (K_BIO_new) { 1045 return (K_BIO_new)(type); 1046 } else { 1047 return nullptr; 1048 } 1049 } 1050 1051 BIO_METHOD *KOpenSSLProxy::BIO_s_mem(void) 1052 { 1053 if (K_BIO_s_mem) { 1054 return (K_BIO_s_mem)(); 1055 } else { 1056 return nullptr; 1057 } 1058 } 1059 1060 BIO *KOpenSSLProxy::BIO_new_fp(FILE *stream, int close_flag) 1061 { 1062 if (K_BIO_new_fp) { 1063 return (K_BIO_new_fp)(stream, close_flag); 1064 } 1065 return nullptr; 1066 } 1067 1068 BIO *KOpenSSLProxy::BIO_new_mem_buf(void *buf, int len) 1069 { 1070 if (K_BIO_new_mem_buf) { 1071 return (K_BIO_new_mem_buf)(buf, len); 1072 } else { 1073 return nullptr; 1074 } 1075 } 1076 1077 int KOpenSSLProxy::BIO_free(BIO *a) 1078 { 1079 if (K_BIO_free) { 1080 return (K_BIO_free)(a); 1081 } 1082 return -1; 1083 } 1084 1085 long KOpenSSLProxy::BIO_ctrl(BIO *bp, int cmd, long larg, void *parg) 1086 { 1087 if (K_BIO_ctrl) { 1088 return (K_BIO_ctrl)(bp, cmd, larg, parg); 1089 } else { 1090 return 0; // failure return for BIO_ctrl is quite individual, maybe we should abort() instead 1091 } 1092 } 1093 1094 int KOpenSSLProxy::BIO_write(BIO *b, const void *data, int len) 1095 { 1096 if (K_BIO_write) { 1097 return (K_BIO_write)(b, data, len); 1098 } else { 1099 return -1; 1100 } 1101 } 1102 1103 int KOpenSSLProxy::PEM_write_bio_X509(BIO *bp, X509 *x) 1104 { 1105 if (K_PEM_ASN1_write_bio) { 1106 return (K_PEM_ASN1_write_bio)((int (*)())K_i2d_X509, PEM_STRING_X509, bp, (char *)x, nullptr, nullptr, 0, nullptr, nullptr); 1107 } else { 1108 return -1; 1109 } 1110 } 1111 1112 int KOpenSSLProxy::ASN1_item_i2d_fp(FILE *out, unsigned char *x) 1113 { 1114 if (K_ASN1_item_i2d_fp && K_NETSCAPE_X509_it) { 1115 return (K_ASN1_item_i2d_fp)(K_NETSCAPE_X509_it, out, x); 1116 } else { 1117 return -1; 1118 } 1119 } 1120 1121 int KOpenSSLProxy::X509_print(FILE *fp, X509 *x) 1122 { 1123 if (K_X509_print_fp) { 1124 return (K_X509_print_fp)(fp, x); 1125 } 1126 return -1; 1127 } 1128 1129 PKCS12 *KOpenSSLProxy::d2i_PKCS12_fp(FILE *fp, PKCS12 **p12) 1130 { 1131 if (K_d2i_PKCS12_fp) { 1132 return (K_d2i_PKCS12_fp)(fp, p12); 1133 } else { 1134 return nullptr; 1135 } 1136 } 1137 1138 int KOpenSSLProxy::PKCS12_newpass(PKCS12 *p12, char *oldpass, char *newpass) 1139 { 1140 if (K_PKCS12_newpass) { 1141 return (K_PKCS12_newpass)(p12, oldpass, newpass); 1142 } else { 1143 return -1; 1144 } 1145 } 1146 1147 int KOpenSSLProxy::i2d_PKCS12(PKCS12 *p12, unsigned char **p) 1148 { 1149 if (K_i2d_PKCS12) { 1150 return (K_i2d_PKCS12)(p12, p); 1151 } else { 1152 return -1; 1153 } 1154 } 1155 1156 int KOpenSSLProxy::i2d_PKCS12_fp(FILE *fp, PKCS12 *p12) 1157 { 1158 if (K_i2d_PKCS12_fp) { 1159 return (K_i2d_PKCS12_fp)(fp, p12); 1160 } else { 1161 return -1; 1162 } 1163 } 1164 1165 PKCS12 *KOpenSSLProxy::PKCS12_new(void) 1166 { 1167 if (K_PKCS12_new) { 1168 return (K_PKCS12_new)(); 1169 } else { 1170 return nullptr; 1171 } 1172 } 1173 1174 void KOpenSSLProxy::PKCS12_free(PKCS12 *a) 1175 { 1176 if (K_PKCS12_free) { 1177 (K_PKCS12_free)(a); 1178 } 1179 } 1180 1181 int KOpenSSLProxy::PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, 1182 X509 **cert, STACK_OF(X509) **ca) 1183 { 1184 if (K_PKCS12_parse) { 1185 return (K_PKCS12_parse)(p12, pass, pkey, cert, ca); 1186 } else { 1187 return -1; 1188 } 1189 } 1190 1191 void KOpenSSLProxy::EVP_PKEY_free(EVP_PKEY *x) 1192 { 1193 if (K_EVP_PKEY_free) { 1194 (K_EVP_PKEY_free)(x); 1195 } 1196 } 1197 1198 EVP_PKEY *KOpenSSLProxy::EVP_PKEY_new() 1199 { 1200 if (K_EVP_PKEY_new) { 1201 return (K_EVP_PKEY_new)(); 1202 } else { 1203 return nullptr; 1204 } 1205 } 1206 1207 void KOpenSSLProxy::X509_REQ_free(X509_REQ *x) 1208 { 1209 if (K_X509_REQ_free) { 1210 (K_X509_REQ_free)(x); 1211 } 1212 } 1213 1214 X509_REQ *KOpenSSLProxy::X509_REQ_new() 1215 { 1216 if (K_X509_REQ_new) { 1217 return (K_X509_REQ_new)(); 1218 } else { 1219 return nullptr; 1220 } 1221 } 1222 1223 int KOpenSSLProxy::SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey) 1224 { 1225 if (K_SSL_CTX_use_PrivateKey) { 1226 return (K_SSL_CTX_use_PrivateKey)(ctx, pkey); 1227 } else { 1228 return -1; 1229 } 1230 } 1231 1232 int KOpenSSLProxy::SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x) 1233 { 1234 if (K_SSL_CTX_use_certificate) { 1235 return (K_SSL_CTX_use_certificate)(ctx, x); 1236 } else { 1237 return -1; 1238 } 1239 } 1240 1241 int KOpenSSLProxy::SSL_get_error(SSL *ssl, int rc) 1242 { 1243 if (K_SSL_get_error) { 1244 return (K_SSL_get_error)(ssl, rc); 1245 } else { 1246 return -1; 1247 } 1248 } 1249 1250 STACK_OF(X509) *KOpenSSLProxy::SSL_get_peer_cert_chain(SSL *s) 1251 { 1252 if (K_SSL_get_peer_cert_chain) { 1253 return (K_SSL_get_peer_cert_chain)(s); 1254 } else { 1255 return nullptr; 1256 } 1257 } 1258 1259 void KOpenSSLProxy::sk_free(STACK *s) 1260 { 1261 if (K_sk_free) { 1262 (K_sk_free)(s); 1263 } 1264 } 1265 1266 int KOpenSSLProxy::sk_num(STACK *s) 1267 { 1268 if (K_sk_num) { 1269 return (K_sk_num)(s); 1270 } else { 1271 return -1; 1272 } 1273 } 1274 1275 char *KOpenSSLProxy::sk_pop(STACK *s) 1276 { 1277 if (K_sk_pop) { 1278 return (K_sk_pop)(s); 1279 } else { 1280 return nullptr; 1281 } 1282 } 1283 1284 char *KOpenSSLProxy::sk_value(STACK *s, int n) 1285 { 1286 if (K_sk_value) { 1287 return (K_sk_value)(s, n); 1288 } else { 1289 return nullptr; 1290 } 1291 } 1292 1293 void KOpenSSLProxy::X509_STORE_CTX_set_chain(X509_STORE_CTX *v, STACK_OF(X509)* x) 1294 { 1295 if (K_X509_STORE_CTX_set_chain) { 1296 (K_X509_STORE_CTX_set_chain)(v, x); 1297 } 1298 } 1299 1300 void KOpenSSLProxy::X509_STORE_CTX_set_purpose(X509_STORE_CTX *v, int purpose) 1301 { 1302 if (K_X509_STORE_CTX_set_purpose) { 1303 (K_X509_STORE_CTX_set_purpose)(v, purpose); 1304 } 1305 } 1306 1307 STACK *KOpenSSLProxy::sk_dup(STACK *s) 1308 { 1309 if (K_sk_dup) { 1310 return (K_sk_dup)(s); 1311 } else { 1312 return nullptr; 1313 } 1314 } 1315 1316 STACK *KOpenSSLProxy::sk_new(int (*cmp)()) 1317 { 1318 if (K_sk_new) { 1319 return (K_sk_new)(cmp); 1320 } else { 1321 return nullptr; 1322 } 1323 } 1324 1325 int KOpenSSLProxy::sk_push(STACK *s, char *d) 1326 { 1327 if (K_sk_push) { 1328 return (K_sk_push)(s, d); 1329 } else { 1330 return -1; 1331 } 1332 } 1333 1334 char *KOpenSSLProxy::i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, ASN1_INTEGER *aint) 1335 { 1336 if (K_i2s_ASN1_INTEGER) { 1337 return (K_i2s_ASN1_INTEGER)(meth, aint); 1338 } else { 1339 return nullptr; 1340 } 1341 } 1342 1343 ASN1_INTEGER *KOpenSSLProxy::X509_get_serialNumber(X509 *x) 1344 { 1345 if (K_X509_get_serialNumber) { 1346 return (K_X509_get_serialNumber)(x); 1347 } else { 1348 return nullptr; 1349 } 1350 } 1351 1352 EVP_PKEY *KOpenSSLProxy::X509_get_pubkey(X509 *x) 1353 { 1354 if (K_X509_get_pubkey) { 1355 return (K_X509_get_pubkey)(x); 1356 } else { 1357 return nullptr; 1358 } 1359 } 1360 1361 int KOpenSSLProxy::i2d_PublicKey(EVP_PKEY *a, unsigned char **pp) 1362 { 1363 if (K_i2d_PublicKey) { 1364 return (K_i2d_PublicKey)(a, pp); 1365 } else { 1366 return 0; 1367 } 1368 } 1369 1370 int KOpenSSLProxy::X509_check_private_key(X509 *x, EVP_PKEY *p) 1371 { 1372 if (K_X509_check_private_key) { 1373 return (K_X509_check_private_key)(x, p); 1374 } 1375 return -1; 1376 } 1377 1378 char *KOpenSSLProxy::BN_bn2hex(const BIGNUM *a) 1379 { 1380 if (K_BN_bn2hex) { 1381 return (K_BN_bn2hex)(a); 1382 } else { 1383 return nullptr; 1384 } 1385 } 1386 1387 int KOpenSSLProxy::X509_digest(const X509 *x, const EVP_MD *t, unsigned char *md, unsigned int *len) 1388 { 1389 if (K_X509_digest) { 1390 return (K_X509_digest)(x, t, md, len); 1391 } else { 1392 return -1; 1393 } 1394 } 1395 1396 EVP_MD *KOpenSSLProxy::EVP_md5() 1397 { 1398 if (K_EVP_md5) { 1399 return (K_EVP_md5)(); 1400 } 1401 return nullptr; 1402 } 1403 1404 void KOpenSSLProxy::ASN1_INTEGER_free(ASN1_INTEGER *a) 1405 { 1406 if (K_ASN1_INTEGER_free) { 1407 (K_ASN1_INTEGER_free)(a); 1408 } 1409 } 1410 1411 int KOpenSSLProxy::OBJ_obj2nid(ASN1_OBJECT *o) 1412 { 1413 if (K_OBJ_obj2nid) { 1414 return (K_OBJ_obj2nid)(o); 1415 } else { 1416 return -1; 1417 } 1418 } 1419 1420 const char *KOpenSSLProxy::OBJ_nid2ln(int n) 1421 { 1422 if (K_OBJ_nid2ln) { 1423 return (K_OBJ_nid2ln)(n); 1424 } else { 1425 return nullptr; 1426 } 1427 } 1428 1429 int KOpenSSLProxy::X509_get_ext_count(X509 *x) 1430 { 1431 if (K_X509_get_ext_count) { 1432 return (K_X509_get_ext_count)(x); 1433 } else { 1434 return -1; 1435 } 1436 } 1437 1438 int KOpenSSLProxy::X509_get_ext_by_NID(X509 *x, int nid, int lastpos) 1439 { 1440 if (K_X509_get_ext_by_NID) { 1441 return (K_X509_get_ext_by_NID)(x, nid, lastpos); 1442 } else { 1443 return -1; 1444 } 1445 } 1446 1447 int KOpenSSLProxy::X509_get_ext_by_OBJ(X509 *x, ASN1_OBJECT *obj, int lastpos) 1448 { 1449 if (K_X509_get_ext_by_OBJ) { 1450 return (K_X509_get_ext_by_OBJ)(x, obj, lastpos); 1451 } else { 1452 return -1; 1453 } 1454 } 1455 1456 X509_EXTENSION *KOpenSSLProxy::X509_get_ext(X509 *x, int loc) 1457 { 1458 if (K_X509_get_ext) { 1459 return (K_X509_get_ext)(x, loc); 1460 } else { 1461 return nullptr; 1462 } 1463 } 1464 1465 X509_EXTENSION *KOpenSSLProxy::X509_delete_ext(X509 *x, int loc) 1466 { 1467 if (K_X509_delete_ext) { 1468 return (K_X509_delete_ext)(x, loc); 1469 } else { 1470 return nullptr; 1471 } 1472 } 1473 1474 int KOpenSSLProxy::X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc) 1475 { 1476 if (K_X509_add_ext) { 1477 return (K_X509_add_ext)(x, ex, loc); 1478 } else { 1479 return -1; 1480 } 1481 } 1482 1483 void *KOpenSSLProxy::X509_get_ext_d2i(X509 *x, int nid, int *crit, int *idx) 1484 { 1485 if (K_X509_get_ext_d2i) { 1486 return (K_X509_get_ext_d2i)(x, nid, crit, idx); 1487 } else { 1488 return nullptr; 1489 } 1490 } 1491 1492 char *KOpenSSLProxy::i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *ia5) 1493 { 1494 if (K_i2s_ASN1_OCTET_STRING) { 1495 return (K_i2s_ASN1_OCTET_STRING)(method, ia5); 1496 } else { 1497 return nullptr; 1498 } 1499 } 1500 1501 int KOpenSSLProxy::ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n) 1502 { 1503 if (K_ASN1_BIT_STRING_get_bit) { 1504 return (K_ASN1_BIT_STRING_get_bit)(a, n); 1505 } else { 1506 return -1; 1507 } 1508 } 1509 1510 PKCS7 *KOpenSSLProxy::PKCS7_new(void) 1511 { 1512 if (K_PKCS7_new) { 1513 return (K_PKCS7_new)(); 1514 } else { 1515 return nullptr; 1516 } 1517 } 1518 1519 void KOpenSSLProxy::PKCS7_free(PKCS7 *a) 1520 { 1521 if (K_PKCS7_free) { 1522 (K_PKCS7_free)(a); 1523 } 1524 } 1525 1526 void KOpenSSLProxy::PKCS7_content_free(PKCS7 *a) 1527 { 1528 if (K_PKCS7_content_free) { 1529 (K_PKCS7_content_free)(a); 1530 } 1531 } 1532 1533 int KOpenSSLProxy::i2d_PKCS7(PKCS7 *a, unsigned char **pp) 1534 { 1535 if (K_i2d_PKCS7) { 1536 return (K_i2d_PKCS7)(a, pp); 1537 } else { 1538 return -1; 1539 } 1540 } 1541 1542 PKCS7 *KOpenSSLProxy::d2i_PKCS7(PKCS7 **a, unsigned char **pp, long length) 1543 { 1544 if (K_d2i_PKCS7) { 1545 return (K_d2i_PKCS7)(a, pp, length); 1546 } else { 1547 return nullptr; 1548 } 1549 } 1550 1551 int KOpenSSLProxy::i2d_PKCS7_fp(FILE *fp, PKCS7 *p7) 1552 { 1553 if (K_i2d_PKCS7_fp) { 1554 return (K_i2d_PKCS7_fp)(fp, p7); 1555 } else { 1556 return -1; 1557 } 1558 } 1559 1560 PKCS7 *KOpenSSLProxy::d2i_PKCS7_fp(FILE *fp, PKCS7 **p7) 1561 { 1562 if (K_d2i_PKCS7_fp) { 1563 return (K_d2i_PKCS7_fp)(fp, p7); 1564 } else { 1565 return nullptr; 1566 } 1567 } 1568 1569 int KOpenSSLProxy::i2d_PKCS7_bio(BIO *bp, PKCS7 *p7) 1570 { 1571 if (K_i2d_PKCS7_bio) { 1572 return (K_i2d_PKCS7_bio)(bp, p7); 1573 } else { 1574 return -1; 1575 } 1576 } 1577 1578 PKCS7 *KOpenSSLProxy::d2i_PKCS7_bio(BIO *bp, PKCS7 **p7) 1579 { 1580 if (K_d2i_PKCS7_bio) { 1581 return (K_d2i_PKCS7_bio)(bp, p7); 1582 } else { 1583 return nullptr; 1584 } 1585 } 1586 1587 PKCS7 *KOpenSSLProxy::PKCS7_dup(PKCS7 *p7) 1588 { 1589 if (K_PKCS7_dup) { 1590 return (K_PKCS7_dup)(p7); 1591 } else { 1592 return nullptr; 1593 } 1594 } 1595 1596 PKCS7 *KOpenSSLProxy::PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, 1597 BIO *data, int flags) 1598 { 1599 if (K_PKCS7_sign) { 1600 return (K_PKCS7_sign)(signcert, pkey, certs, data, flags); 1601 } else { 1602 return nullptr; 1603 } 1604 } 1605 1606 int KOpenSSLProxy::PKCS7_verify(PKCS7 *p, STACK_OF(X509)* st, X509_STORE *s, BIO *in, BIO *out, int flags) 1607 { 1608 if (K_PKCS7_verify) { 1609 return (K_PKCS7_verify)(p, st, s, in, out, flags); 1610 } else { 1611 return 0; 1612 } 1613 } 1614 1615 STACK_OF(X509) *KOpenSSLProxy::PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags) 1616 { 1617 if (K_PKCS7_get0_signers) { 1618 return (K_PKCS7_get0_signers)(p7, certs, flags); 1619 } else { 1620 return nullptr; 1621 } 1622 } 1623 1624 PKCS7 *KOpenSSLProxy::PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, EVP_CIPHER *cipher, 1625 int flags) 1626 { 1627 if (K_PKCS7_encrypt) { 1628 return (K_PKCS7_encrypt)(certs, in, cipher, flags); 1629 } else { 1630 return nullptr; 1631 } 1632 } 1633 1634 int KOpenSSLProxy::PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags) 1635 { 1636 if (K_PKCS7_decrypt) { 1637 return (K_PKCS7_decrypt)(p7, pkey, cert, data, flags); 1638 } else { 1639 return 0; 1640 } 1641 } 1642 1643 STACK_OF(X509_NAME) *KOpenSSLProxy::SSL_load_client_CA_file(const char *file) 1644 { 1645 if (K_SSL_load_client_CA_file) { 1646 return (K_SSL_load_client_CA_file)(file); 1647 } else { 1648 return nullptr; 1649 } 1650 } 1651 1652 STACK_OF(X509_INFO) *KOpenSSLProxy::PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u) 1653 { 1654 if (K_PEM_X509_INFO_read) { 1655 return (K_PEM_X509_INFO_read)(fp, sk, cb, u); 1656 } else { 1657 return nullptr; 1658 } 1659 } 1660 1661 X509 *KOpenSSLProxy::X509_d2i_fp(FILE *out, X509 **buf) 1662 { 1663 if (K_ASN1_d2i_fp) { 1664 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))); 1665 } else { 1666 return nullptr; 1667 } 1668 } 1669 1670 int KOpenSSLProxy::SSL_peek(SSL *ssl, void *buf, int num) 1671 { 1672 if (K_SSL_peek) { 1673 return (K_SSL_peek)(ssl, buf, num); 1674 } else { 1675 return -1; 1676 } 1677 } 1678 1679 const char *KOpenSSLProxy::RAND_file_name(char *buf, size_t num) 1680 { 1681 if (K_RAND_file_name) { 1682 return (K_RAND_file_name)(buf, num); 1683 } else { 1684 return nullptr; 1685 } 1686 } 1687 1688 int KOpenSSLProxy::RAND_load_file(const char *filename, long max_bytes) 1689 { 1690 if (K_RAND_load_file) { 1691 return (K_RAND_load_file)(filename, max_bytes); 1692 } else { 1693 return -1; 1694 } 1695 } 1696 1697 int KOpenSSLProxy::RAND_write_file(const char *filename) 1698 { 1699 if (K_RAND_write_file) { 1700 return (K_RAND_write_file)(filename); 1701 } else { 1702 return -1; 1703 } 1704 } 1705 1706 int KOpenSSLProxy::X509_PURPOSE_get_count() 1707 { 1708 if (K_X509_PURPOSE_get_count) { 1709 return (K_X509_PURPOSE_get_count)(); 1710 } else { 1711 return -1; 1712 } 1713 } 1714 1715 int KOpenSSLProxy::X509_PURPOSE_get_id(X509_PURPOSE *p) 1716 { 1717 if (K_X509_PURPOSE_get_id) { 1718 return (K_X509_PURPOSE_get_id)(p); 1719 } else { 1720 return -1; 1721 } 1722 } 1723 1724 int KOpenSSLProxy::X509_check_purpose(X509 *x, int id, int ca) 1725 { 1726 if (K_X509_check_purpose) { 1727 return (K_X509_check_purpose)(x, id, ca); 1728 } else { 1729 return -1; 1730 } 1731 } 1732 1733 X509_PURPOSE *KOpenSSLProxy::X509_PURPOSE_get0(int idx) 1734 { 1735 if (K_X509_PURPOSE_get0) { 1736 return (K_X509_PURPOSE_get0)(idx); 1737 } else { 1738 return nullptr; 1739 } 1740 } 1741 1742 int KOpenSSLProxy::EVP_PKEY_assign(EVP_PKEY *pkey, int type, char *key) 1743 { 1744 if (K_EVP_PKEY_assign) { 1745 return (K_EVP_PKEY_assign)(pkey, type, key); 1746 } else { 1747 return -1; 1748 } 1749 } 1750 1751 int KOpenSSLProxy::X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey) 1752 { 1753 if (K_X509_REQ_set_pubkey) { 1754 return (K_X509_REQ_set_pubkey)(x, pkey); 1755 } else { 1756 return -1; 1757 } 1758 } 1759 1760 RSA *KOpenSSLProxy::RSA_generate_key(int bits, unsigned long e, void 1761 (*callback)(int, int, void *), void *cb_arg) 1762 { 1763 if (K_RSA_generate_key) { 1764 return (K_RSA_generate_key)(bits, e, callback, cb_arg); 1765 } else { 1766 return nullptr; 1767 } 1768 } 1769 1770 STACK *KOpenSSLProxy::X509_get1_email(X509 *x) 1771 { 1772 if (K_X509_get1_email) { 1773 return (K_X509_get1_email)(x); 1774 } else { 1775 return nullptr; 1776 } 1777 } 1778 1779 void KOpenSSLProxy::X509_email_free(STACK *sk) 1780 { 1781 if (K_X509_email_free) { 1782 (K_X509_email_free)(sk); 1783 } 1784 } 1785 1786 EVP_CIPHER *KOpenSSLProxy::EVP_des_ede3_cbc() 1787 { 1788 if (K_EVP_des_ede3_cbc) { 1789 return (K_EVP_des_ede3_cbc)(); 1790 } else { 1791 return nullptr; 1792 } 1793 } 1794 1795 EVP_CIPHER *KOpenSSLProxy::EVP_des_cbc() 1796 { 1797 if (K_EVP_des_cbc) { 1798 return (K_EVP_des_cbc)(); 1799 } else { 1800 return nullptr; 1801 } 1802 } 1803 1804 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_cbc() 1805 { 1806 if (K_EVP_rc2_cbc) { 1807 return (K_EVP_rc2_cbc)(); 1808 } else { 1809 return nullptr; 1810 } 1811 } 1812 1813 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_64_cbc() 1814 { 1815 if (K_EVP_rc2_64_cbc) { 1816 return (K_EVP_rc2_64_cbc)(); 1817 } else { 1818 return nullptr; 1819 } 1820 } 1821 1822 EVP_CIPHER *KOpenSSLProxy::EVP_rc2_40_cbc() 1823 { 1824 if (K_EVP_rc2_40_cbc) { 1825 return (K_EVP_rc2_40_cbc)(); 1826 } else { 1827 return nullptr; 1828 } 1829 } 1830 1831 int KOpenSSLProxy::i2d_X509_REQ_fp(FILE *fp, X509_REQ *x) 1832 { 1833 if (K_i2d_X509_REQ_fp) { 1834 return (K_i2d_X509_REQ_fp)(fp, x); 1835 } else { 1836 return -1; 1837 } 1838 } 1839 1840 void KOpenSSLProxy::ERR_clear_error() 1841 { 1842 if (K_ERR_clear_error) { 1843 (K_ERR_clear_error)(); 1844 } 1845 } 1846 1847 unsigned long KOpenSSLProxy::ERR_get_error() 1848 { 1849 if (K_ERR_get_error) { 1850 return (K_ERR_get_error)(); 1851 } else { 1852 return 0xffffffff; 1853 } 1854 } 1855 1856 void KOpenSSLProxy::ERR_print_errors_fp(FILE *fp) 1857 { 1858 if (K_ERR_print_errors_fp) { 1859 (K_ERR_print_errors_fp)(fp); 1860 } 1861 } 1862 1863 SSL_SESSION *KOpenSSLProxy::SSL_get1_session(SSL *ssl) 1864 { 1865 if (K_SSL_get1_session) { 1866 return (K_SSL_get1_session)(ssl); 1867 } else { 1868 return nullptr; 1869 } 1870 } 1871 1872 void KOpenSSLProxy::SSL_SESSION_free(SSL_SESSION *session) 1873 { 1874 if (K_SSL_SESSION_free) { 1875 (K_SSL_SESSION_free)(session); 1876 } 1877 } 1878 1879 int KOpenSSLProxy::SSL_set_session(SSL *ssl, SSL_SESSION *session) 1880 { 1881 if (K_SSL_set_session) { 1882 return (K_SSL_set_session)(ssl, session); 1883 } else { 1884 return -1; 1885 } 1886 } 1887 1888 SSL_SESSION *KOpenSSLProxy::d2i_SSL_SESSION(SSL_SESSION **a, unsigned char **pp, long length) 1889 { 1890 if (K_d2i_SSL_SESSION) { 1891 return (K_d2i_SSL_SESSION)(a, pp, length); 1892 } else { 1893 return nullptr; 1894 } 1895 } 1896 1897 int KOpenSSLProxy::i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp) 1898 { 1899 if (K_i2d_SSL_SESSION) { 1900 return (K_i2d_SSL_SESSION)(in, pp); 1901 } else { 1902 return -1; 1903 } 1904 } 1905 1906 int KOpenSSLProxy::i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *p) 1907 { 1908 if (K_i2d_PrivateKey_fp) { 1909 return (K_i2d_PrivateKey_fp)(fp, p); 1910 } else { 1911 return -1; 1912 } 1913 } 1914 1915 int KOpenSSLProxy::i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *p, const EVP_CIPHER *c, char *k, int klen, pem_password_cb *cb, void *u) 1916 { 1917 if (K_i2d_PKCS8PrivateKey_fp) { 1918 return (K_i2d_PKCS8PrivateKey_fp)(fp, p, c, k, klen, cb, u); 1919 } else { 1920 return -1; 1921 } 1922 } 1923 1924 void KOpenSSLProxy::RSA_free(RSA *rsa) 1925 { 1926 if (K_RSA_free) { 1927 (K_RSA_free)(rsa); 1928 } 1929 } 1930 1931 EVP_CIPHER *KOpenSSLProxy::EVP_bf_cbc() 1932 { 1933 if (K_EVP_bf_cbc) { 1934 return (K_EVP_bf_cbc)(); 1935 } 1936 return nullptr; 1937 } 1938 1939 int KOpenSSLProxy::X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md) 1940 { 1941 if (K_X509_REQ_sign) { 1942 return (K_X509_REQ_sign)(x, pkey, md); 1943 } 1944 return -1; 1945 } 1946 1947 int KOpenSSLProxy::X509_NAME_add_entry_by_txt(X509_NAME *name, char *field, 1948 int type, unsigned char *bytes, int len, int loc, int set) 1949 { 1950 if (K_X509_NAME_add_entry_by_txt) { 1951 return (K_X509_NAME_add_entry_by_txt)(name, field, type, bytes, len, loc, set); 1952 } 1953 return -1; 1954 } 1955 1956 X509_NAME *KOpenSSLProxy::X509_NAME_new() 1957 { 1958 if (K_X509_NAME_new) { 1959 return (K_X509_NAME_new)(); 1960 } 1961 return nullptr; 1962 } 1963 1964 int KOpenSSLProxy::X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name) 1965 { 1966 if (K_X509_REQ_set_subject_name) { 1967 return (K_X509_REQ_set_subject_name)(req, name); 1968 } 1969 return -1; 1970 } 1971 1972 unsigned char *KOpenSSLProxy::ASN1_STRING_data(ASN1_STRING *x) 1973 { 1974 if (K_ASN1_STRING_data) { 1975 return (K_ASN1_STRING_data)(x); 1976 } 1977 return nullptr; 1978 } 1979 1980 int KOpenSSLProxy::ASN1_STRING_length(ASN1_STRING *x) 1981 { 1982 if (K_ASN1_STRING_length) { 1983 return (K_ASN1_STRING_length)(x); 1984 } 1985 return 0L; 1986 } 1987 1988 STACK_OF(SSL_CIPHER) *KOpenSSLProxy::SSL_get_ciphers(const SSL *ssl) 1989 { 1990 if (K_SSL_get_ciphers) { 1991 return (K_SSL_get_ciphers)(ssl); 1992 } 1993 return nullptr; 1994 } 1995 1996 #endif 1997