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