Line 0
Link Here
|
|
|
1 |
--- kio/kssl/kopenssl.cpp.orig 2018-11-13 17:02:53 UTC |
2 |
+++ kio/kssl/kopenssl.cpp |
3 |
@@ -75,18 +75,26 @@ static void (*K_X509_STORE_CTX_free) (X5 |
4 |
static int (*K_X509_verify_cert) (X509_STORE_CTX *) = 0L; |
5 |
static X509_STORE_CTX *(*K_X509_STORE_CTX_new) (void) = 0L; |
6 |
static void (*K_X509_STORE_free) (X509_STORE *) = 0L; |
7 |
+static void (*K_X509_STORE_set_verify_cb)(X509_STORE *, int (*)(int, X509_STORE_CTX *)) = nullptr; |
8 |
static X509_STORE *(*K_X509_STORE_new) (void) = 0L; |
9 |
static void (*K_X509_free) (X509 *) = 0L; |
10 |
static char *(*K_X509_NAME_oneline) (X509_NAME *,char *,int) = 0L; |
11 |
static X509_NAME *(*K_X509_get_subject_name) (X509 *) = 0L; |
12 |
static X509_NAME *(*K_X509_get_issuer_name) (X509 *) = 0L; |
13 |
+static void (*K_X509_get0_signature)(const ASN1_BIT_STRING **psig, const X509_ALGOR **palg, const X509 *x) = nullptr; |
14 |
static X509_LOOKUP *(*K_X509_STORE_add_lookup) (X509_STORE *, X509_LOOKUP_METHOD *) = 0L; |
15 |
static X509_LOOKUP_METHOD *(*K_X509_LOOKUP_file)(void) = 0L; |
16 |
static void (*K_X509_LOOKUP_free)(X509_LOOKUP *) = 0L; |
17 |
static int (*K_X509_LOOKUP_ctrl)(X509_LOOKUP *, int, const char *, long, char **) = 0L; |
18 |
static void (*K_X509_STORE_CTX_init)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *) = 0L; |
19 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
20 |
static void (*K_CRYPTO_free) (void *) = 0L; |
21 |
+#else |
22 |
+static void (*K_CRYPTO_free)(void *, const char *, int) = 0L; |
23 |
+#endif |
24 |
static X509* (*K_X509_dup) (X509 *) = 0L; |
25 |
+static ASN1_TIME *(*K_X509_getm_notBefore)(const X509 *) = 0L; |
26 |
+static ASN1_TIME *(*K_X509_getm_notAfter)(const X509 *) = 0L; |
27 |
static BIO_METHOD *(*K_BIO_s_mem) (void) = 0L; |
28 |
static BIO* (*K_BIO_new) (BIO_METHOD *) = 0L; |
29 |
static BIO* (*K_BIO_new_fp) (FILE *, int) = 0L; |
30 |
@@ -118,13 +126,16 @@ static int (*K_SSL_get_error) (SSL*, int |
31 |
static STACK_OF(X509)* (*K_SSL_get_peer_cert_chain) (SSL*) = 0L; |
32 |
static void (*K_X509_STORE_CTX_set_chain) (X509_STORE_CTX *, STACK_OF(X509)*) = 0L; |
33 |
static void (*K_X509_STORE_CTX_set_purpose) (X509_STORE_CTX *, int) = 0L; |
34 |
-static void (*K_sk_free) (STACK*) = 0L; |
35 |
-static int (*K_sk_num) (STACK*) = 0L; |
36 |
-static char* (*K_sk_pop) (STACK*) = 0L; |
37 |
-static char* (*K_sk_value) (STACK*, int) = 0L; |
38 |
-static STACK* (*K_sk_new) (int (*)()) = 0L; |
39 |
-static int (*K_sk_push) (STACK*, char*) = 0L; |
40 |
-static STACK* (*K_sk_dup) (STACK *) = 0L; |
41 |
+static X509 *(*K_X509_STORE_CTX_get_current_cert)(X509_STORE_CTX *) = nullptr; |
42 |
+static void (*K_X509_STORE_CTX_set_error)(X509_STORE_CTX *, int) = nullptr; |
43 |
+static int (*K_X509_STORE_CTX_get_error)(X509_STORE_CTX *) = nullptr; |
44 |
+static void (*K_OPENSSL_sk_free)(STACK *) = nullptr; |
45 |
+static int (*K_OPENSSL_sk_num)(STACK *) = nullptr; |
46 |
+static char *(*K_OPENSSL_sk_pop)(STACK *) = nullptr; |
47 |
+static char *(*K_OPENSSL_sk_value)(STACK *, int) = nullptr; |
48 |
+static STACK *(*K_OPENSSL_sk_new)(int (*)()) = nullptr; |
49 |
+static int (*K_OPENSSL_sk_push)(STACK *, char *) = nullptr; |
50 |
+static STACK *(*K_OPENSSL_sk_dup)(STACK *) = nullptr; |
51 |
static char * (*K_i2s_ASN1_INTEGER) (X509V3_EXT_METHOD *, ASN1_INTEGER *) =0L; |
52 |
static ASN1_INTEGER * (*K_X509_get_serialNumber) (X509 *) = 0L; |
53 |
static EVP_PKEY *(*K_X509_get_pubkey)(X509 *) = 0L; |
54 |
@@ -164,6 +175,12 @@ static int (*K_X509_PURPOSE_get_id)(X509 |
55 |
static int (*K_X509_check_purpose)(X509*,int,int) = 0L; |
56 |
static X509_PURPOSE* (*K_X509_PURPOSE_get0)(int) = 0L; |
57 |
static int (*K_EVP_PKEY_assign)(EVP_PKEY*, int, char*) = 0L; |
58 |
+static int (*K_EVP_PKEY_base_id)(EVP_PKEY *) = nullptr; |
59 |
+static RSA *(*K_EVP_PKEY_get0_RSA)(EVP_PKEY *) = nullptr; |
60 |
+static void (*K_RSA_get0_key)(RSA *, const BIGNUM **, const BIGNUM **, const BIGNUM **) = nullptr; |
61 |
+static DSA *(*K_EVP_PKEY_get0_DSA)(EVP_PKEY *) = nullptr; |
62 |
+static void (*K_DSA_get0_pqg)(DSA *, const BIGNUM **, const BIGNUM **, const BIGNUM **) = nullptr; |
63 |
+static void (*K_DSA_get0_key)(DSA *, const BIGNUM **, const BIGNUM **) = nullptr; |
64 |
static int (*K_X509_REQ_set_pubkey)(X509_REQ*, EVP_PKEY*) = 0L; |
65 |
static RSA *(*K_RSA_generate_key)(int, unsigned long, void (*)(int,int,void *), void *) = 0L; |
66 |
static int (*K_i2d_X509_REQ_fp)(FILE*, X509_REQ*) = 0L; |
67 |
@@ -410,7 +427,11 @@ KOpenSSLProxy::KOpenSSLProxy() |
68 |
K_RAND_load_file = (int (*)(const char *, long)) d->cryptoLib->resolveFunction("RAND_load_file"); |
69 |
K_RAND_file_name = (const char* (*)(char *, size_t)) d->cryptoLib->resolveFunction("RAND_file_name"); |
70 |
K_RAND_write_file = (int (*)(const char *)) d->cryptoLib->resolveFunction("RAND_write_file"); |
71 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
72 |
K_CRYPTO_free = (void (*) (void *)) d->cryptoLib->resolveFunction("CRYPTO_free"); |
73 |
+#else |
74 |
+ K_CRYPTO_free = (void (*)(void *, const char *, int)) d->cryptoLib->resolve("CRYPTO_free"); |
75 |
+#endif |
76 |
K_d2i_X509 = (X509 * (*)(X509 **,unsigned char **,long)) d->cryptoLib->resolveFunction("d2i_X509"); |
77 |
K_i2d_X509 = (int (*)(X509 *,unsigned char **)) d->cryptoLib->resolveFunction("i2d_X509"); |
78 |
K_X509_cmp = (int (*)(X509 *, X509 *)) d->cryptoLib->resolveFunction("X509_cmp"); |
79 |
@@ -419,15 +440,19 @@ KOpenSSLProxy::KOpenSSLProxy() |
80 |
K_X509_verify_cert = (int (*) (X509_STORE_CTX *)) d->cryptoLib->resolveFunction("X509_verify_cert"); |
81 |
K_X509_STORE_new = (X509_STORE * (*) (void)) d->cryptoLib->resolveFunction("X509_STORE_new"); |
82 |
K_X509_STORE_free = (void (*) (X509_STORE *)) d->cryptoLib->resolveFunction("X509_STORE_free"); |
83 |
+ K_X509_STORE_set_verify_cb = (void (*)(X509_STORE *, int (*)(int, X509_STORE_CTX *))) d->cryptoLib->resolve("X509_STORE_set_verify_cb"); |
84 |
K_X509_NAME_oneline = (char * (*) (X509_NAME *,char *,int)) d->cryptoLib->resolveFunction("X509_NAME_oneline"); |
85 |
K_X509_get_subject_name = (X509_NAME * (*) (X509 *)) d->cryptoLib->resolveFunction("X509_get_subject_name"); |
86 |
K_X509_get_issuer_name = (X509_NAME * (*) (X509 *)) d->cryptoLib->resolveFunction("X509_get_issuer_name"); |
87 |
+ K_X509_get0_signature = (void (*)(const ASN1_BIT_STRING **, const X509_ALGOR **, const X509 *)) d->cryptoLib->resolve("X509_get0_signature"); |
88 |
K_X509_STORE_add_lookup = (X509_LOOKUP *(*) (X509_STORE *, X509_LOOKUP_METHOD *)) d->cryptoLib->resolveFunction("X509_STORE_add_lookup"); |
89 |
K_X509_LOOKUP_file = (X509_LOOKUP_METHOD *(*)(void)) d->cryptoLib->resolveFunction("X509_LOOKUP_file"); |
90 |
K_X509_LOOKUP_free = (void (*)(X509_LOOKUP *)) d->cryptoLib->resolveFunction("X509_LOOKUP_free"); |
91 |
K_X509_LOOKUP_ctrl = (int (*)(X509_LOOKUP *, int, const char *, long, char **)) d->cryptoLib->resolveFunction("X509_LOOKUP_ctrl"); |
92 |
K_X509_STORE_CTX_init = (void (*)(X509_STORE_CTX *, X509_STORE *, X509 *, STACK_OF(X509) *)) d->cryptoLib->resolveFunction("X509_STORE_CTX_init"); |
93 |
K_X509_dup = (X509* (*)(X509*)) d->cryptoLib->resolveFunction("X509_dup"); |
94 |
+ K_X509_getm_notBefore = (ASN1_TIME *(*)(const X509 *)) d->cryptoLib->resolve("X509_getm_notBefore"); |
95 |
+ K_X509_getm_notAfter = (ASN1_TIME *(*)(const X509 *)) d->cryptoLib->resolve("X509_getm_notAfter"); |
96 |
K_BIO_s_mem = (BIO_METHOD *(*) (void)) d->cryptoLib->resolveFunction("BIO_s_mem"); |
97 |
K_BIO_new = (BIO* (*)(BIO_METHOD *)) d->cryptoLib->resolveFunction("BIO_new"); |
98 |
K_BIO_new_fp = (BIO* (*)(FILE*, int)) d->cryptoLib->resolveFunction("BIO_new_fp"); |
99 |
@@ -454,13 +479,26 @@ KOpenSSLProxy::KOpenSSLProxy() |
100 |
K_X509_REQ_new = (X509_REQ* (*)()) d->cryptoLib->resolveFunction("X509_REQ_new"); |
101 |
K_X509_STORE_CTX_set_chain = (void (*)(X509_STORE_CTX *, STACK_OF(X509)*)) d->cryptoLib->resolveFunction("X509_STORE_CTX_set_chain"); |
102 |
K_X509_STORE_CTX_set_purpose = (void (*)(X509_STORE_CTX *, int)) d->cryptoLib->resolveFunction("X509_STORE_CTX_set_purpose"); |
103 |
- K_sk_free = (void (*) (STACK *)) d->cryptoLib->resolveFunction("sk_free"); |
104 |
- K_sk_num = (int (*) (STACK *)) d->cryptoLib->resolveFunction("sk_num"); |
105 |
- K_sk_pop = (char* (*) (STACK *)) d->cryptoLib->resolveFunction("sk_pop"); |
106 |
- K_sk_value = (char* (*) (STACK *, int)) d->cryptoLib->resolveFunction("sk_value"); |
107 |
- K_sk_new = (STACK* (*) (int (*)())) d->cryptoLib->resolveFunction("sk_new"); |
108 |
- K_sk_push = (int (*) (STACK*, char*)) d->cryptoLib->resolveFunction("sk_push"); |
109 |
- K_sk_dup = (STACK* (*) (STACK *)) d->cryptoLib->resolveFunction("sk_dup"); |
110 |
+ K_X509_STORE_CTX_get_current_cert = (X509 * (*)(X509_STORE_CTX *)) d->cryptoLib->resolve("X509_STORE_CTX_get_current_cert"); |
111 |
+ K_X509_STORE_CTX_set_error = (void (*)(X509_STORE_CTX *, int)) d->cryptoLib->resolve("X509_STORE_CTX_set_error"); |
112 |
+ K_X509_STORE_CTX_get_error = (int (*)(X509_STORE_CTX *)) d->cryptoLib->resolve("X509_STORE_CTX_get_error"); |
113 |
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L |
114 |
+ K_OPENSSL_sk_free = (void (*)(STACK *)) d->cryptoLib->resolve("OPENSSL_sk_free"); |
115 |
+ K_OPENSSL_sk_num = (int (*)(STACK *)) d->cryptoLib->resolve("OPENSSL_sk_num"); |
116 |
+ K_OPENSSL_sk_pop = (char *(*)(STACK *)) d->cryptoLib->resolve("OPENSSL_sk_pop"); |
117 |
+ K_OPENSSL_sk_value = (char *(*)(STACK *, int)) d->cryptoLib->resolve("OPENSSL_sk_value"); |
118 |
+ K_OPENSSL_sk_new = (STACK * (*)(int (*)())) d->cryptoLib->resolve("OPENSSL_sk_new"); |
119 |
+ K_OPENSSL_sk_push = (int (*)(STACK *, char *)) d->cryptoLib->resolve("OPENSSL_sk_push"); |
120 |
+ K_OPENSSL_sk_dup = (STACK * (*)(STACK *)) d->cryptoLib->resolve("OPENSSL_sk_dup"); |
121 |
+#else |
122 |
+ K_OPENSSL_sk_free = (void (*)(STACK *)) d->cryptoLib->resolve("sk_free"); |
123 |
+ K_OPENSSL_sk_num = (int (*)(STACK *)) d->cryptoLib->resolve("sk_num"); |
124 |
+ K_OPENSSL_sk_pop = (char *(*)(STACK *)) d->cryptoLib->resolve("sk_pop"); |
125 |
+ K_OPENSSL_sk_value = (char *(*)(STACK *, int)) d->cryptoLib->resolve("sk_value"); |
126 |
+ K_OPENSSL_sk_new = (STACK * (*)(int (*)())) d->cryptoLib->resolve("sk_new"); |
127 |
+ K_OPENSSL_sk_push = (int (*)(STACK *, char *)) d->cryptoLib->resolve("sk_push"); |
128 |
+ K_OPENSSL_sk_dup = (STACK * (*)(STACK *)) d->cryptoLib->resolve("sk_dup"); |
129 |
+#endif |
130 |
K_i2s_ASN1_INTEGER = (char *(*) (X509V3_EXT_METHOD *, ASN1_INTEGER *)) d->cryptoLib->resolveFunction("i2s_ASN1_INTEGER"); |
131 |
K_X509_get_serialNumber = (ASN1_INTEGER * (*) (X509 *)) d->cryptoLib->resolveFunction("X509_get_serialNumber"); |
132 |
K_X509_get_pubkey = (EVP_PKEY *(*)(X509 *)) d->cryptoLib->resolveFunction("X509_get_pubkey"); |
133 |
@@ -504,6 +542,12 @@ KOpenSSLProxy::KOpenSSLProxy() |
134 |
K_X509_check_purpose = (int (*)(X509*,int,int)) d->cryptoLib->resolveFunction("X509_check_purpose"); |
135 |
K_X509_PURPOSE_get0 = (X509_PURPOSE *(*)(int)) d->cryptoLib->resolveFunction("X509_PURPOSE_get0"); |
136 |
K_EVP_PKEY_assign = (int (*)(EVP_PKEY*, int, char*)) d->cryptoLib->resolveFunction("EVP_PKEY_assign"); |
137 |
+ K_EVP_PKEY_base_id = (int (*)(EVP_PKEY *)) d->cryptoLib->resolve("EVP_PKEY_base_id"); |
138 |
+ K_EVP_PKEY_get0_RSA = (RSA *(*)(EVP_PKEY *)) d->cryptoLib->resolve("EVP_PKEY_get0_RSA"); |
139 |
+ K_RSA_get0_key = (void (*)(RSA *, const BIGNUM **, const BIGNUM **, const BIGNUM **)) d->cryptoLib->resolve("ESA_get0_key"); |
140 |
+ K_EVP_PKEY_get0_DSA = (DSA *(*)(EVP_PKEY *)) d->cryptoLib->resolve("EVP_PKEY_get0_DSA"); |
141 |
+ K_DSA_get0_pqg = (void (*)(DSA *, const BIGNUM **, const BIGNUM **, const BIGNUM **)) d->cryptoLib->resolve("DSA_get0_pqg"); |
142 |
+ K_DSA_get0_key = (void (*)(DSA *, const BIGNUM **, const BIGNUM **)) d->cryptoLib->resolve("DSA_get0_key"); |
143 |
K_X509_REQ_set_pubkey = (int (*)(X509_REQ*, EVP_PKEY*)) d->cryptoLib->resolveFunction("X509_REQ_set_pubkey"); |
144 |
K_RSA_generate_key = (RSA* (*)(int, unsigned long, void (*)(int,int,void *), void *)) d->cryptoLib->resolveFunction("RSA_generate_key"); |
145 |
K_i2d_X509_REQ_fp = (int (*)(FILE *, X509_REQ *)) d->cryptoLib->resolveFunction("i2d_X509_REQ_fp"); |
146 |
@@ -865,6 +909,16 @@ void KOpenSSLProxy::X509_STORE_free(X509 |
147 |
if (K_X509_STORE_free) (K_X509_STORE_free)(v); |
148 |
} |
149 |
|
150 |
+void KOpenSSLProxy::X509_STORE_set_verify_cb(X509_STORE *store, int (*verify_cb)(int, X509_STORE_CTX *)) |
151 |
+{ |
152 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
153 |
+ X509_STORE_set_verify_cb_func(store, verify_cb); |
154 |
+#else |
155 |
+ if (K_X509_STORE_set_verify_cb) { |
156 |
+ (K_X509_STORE_set_verify_cb)(store, verify_cb); |
157 |
+ } |
158 |
+#endif |
159 |
+} |
160 |
|
161 |
X509_STORE_CTX *KOpenSSLProxy::X509_STORE_CTX_new(void) { |
162 |
if (K_X509_STORE_CTX_new) return (K_X509_STORE_CTX_new)(); |
163 |
@@ -905,6 +959,21 @@ X509_NAME *KOpenSSLProxy::X509_get_issue |
164 |
return 0L; |
165 |
} |
166 |
|
167 |
+void KOpenSSLProxy::X509_get0_signature(const ASN1_BIT_STRING **psig, const X509_ALGOR **algor, const X509 *x) |
168 |
+{ |
169 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
170 |
+ if (psig) { |
171 |
+ *psig = x->signature; |
172 |
+ } |
173 |
+ if (algor) { |
174 |
+ *algor = x->sig_alg; |
175 |
+ } |
176 |
+#else |
177 |
+ if (K_X509_get0_signature) { |
178 |
+ return (K_X509_get0_signature)(psig, algor, x); |
179 |
+ } |
180 |
+#endif |
181 |
+} |
182 |
|
183 |
X509_LOOKUP *KOpenSSLProxy::X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m) { |
184 |
if (K_X509_STORE_add_lookup) return (K_X509_STORE_add_lookup)(v,m); |
185 |
@@ -934,16 +1003,49 @@ void KOpenSSLProxy::X509_STORE_CTX_init( |
186 |
} |
187 |
|
188 |
|
189 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
190 |
void KOpenSSLProxy::CRYPTO_free(void *x) { |
191 |
if (K_CRYPTO_free) (K_CRYPTO_free)(x); |
192 |
} |
193 |
- |
194 |
+#else |
195 |
+void KOpenSSLProxy::CRYPTO_free(void *x, const char *file, int line) |
196 |
+{ |
197 |
+ if (K_CRYPTO_free) { |
198 |
+ K_CRYPTO_free(x, file, line); |
199 |
+ } |
200 |
+} |
201 |
+#endif |
202 |
|
203 |
X509 *KOpenSSLProxy::X509_dup(X509 *x509) { |
204 |
if (K_X509_dup) return (K_X509_dup)(x509); |
205 |
return 0L; |
206 |
} |
207 |
|
208 |
+ASN1_TIME *KOpenSSLProxy::X509_getm_notBefore(const X509 *x) |
209 |
+{ |
210 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
211 |
+ return X509_get_notBefore(x); |
212 |
+#else |
213 |
+ if (K_X509_getm_notBefore) { |
214 |
+ return (K_X509_getm_notBefore)(x); |
215 |
+ } else { |
216 |
+ return nullptr; |
217 |
+ } |
218 |
+#endif |
219 |
+} |
220 |
+ |
221 |
+ASN1_TIME *KOpenSSLProxy::X509_getm_notAfter(const X509 *x) |
222 |
+{ |
223 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
224 |
+ return X509_get_notAfter(x); |
225 |
+#else |
226 |
+ if (K_X509_getm_notAfter) { |
227 |
+ return (K_X509_getm_notAfter)(x); |
228 |
+ } else { |
229 |
+ return nullptr; |
230 |
+ } |
231 |
+#endif |
232 |
+} |
233 |
|
234 |
BIO *KOpenSSLProxy::BIO_new(BIO_METHOD *type) { |
235 |
if (K_BIO_new) return (K_BIO_new)(type); |
236 |
@@ -1093,25 +1195,25 @@ STACK_OF(X509) *KOpenSSLProxy::SSL_get_p |
237 |
} |
238 |
|
239 |
|
240 |
-void KOpenSSLProxy::sk_free(STACK *s) { |
241 |
- if (K_sk_free) (K_sk_free)(s); |
242 |
+void KOpenSSLProxy::OPENSSL_sk_free(STACK *s) { |
243 |
+ if (K_OPENSSL_sk_free) (K_OPENSSL_sk_free)(s); |
244 |
} |
245 |
|
246 |
|
247 |
-int KOpenSSLProxy::sk_num(STACK *s) { |
248 |
- if (K_sk_num) return (K_sk_num)(s); |
249 |
+int KOpenSSLProxy::OPENSSL_sk_num(STACK *s) { |
250 |
+ if (K_OPENSSL_sk_num) return (K_OPENSSL_sk_num)(s); |
251 |
else return -1; |
252 |
} |
253 |
|
254 |
|
255 |
-char *KOpenSSLProxy::sk_pop(STACK *s) { |
256 |
- if (K_sk_pop) return (K_sk_pop)(s); |
257 |
+char *KOpenSSLProxy::OPENSSL_sk_pop(STACK *s) { |
258 |
+ if (K_OPENSSL_sk_pop) return (K_OPENSSL_sk_pop)(s); |
259 |
else return 0L; |
260 |
} |
261 |
|
262 |
|
263 |
-char *KOpenSSLProxy::sk_value(STACK *s, int n) { |
264 |
- if (K_sk_value) return (K_sk_value)(s, n); |
265 |
+char *KOpenSSLProxy::OPENSSL_sk_value(STACK *s, int n) { |
266 |
+ if (K_OPENSSL_sk_value) return (K_OPENSSL_sk_value)(s, n); |
267 |
else return 0L; |
268 |
} |
269 |
|
270 |
@@ -1124,21 +1226,57 @@ void KOpenSSLProxy::X509_STORE_CTX_set_p |
271 |
if (K_X509_STORE_CTX_set_purpose) (K_X509_STORE_CTX_set_purpose)(v,purpose); |
272 |
} |
273 |
|
274 |
+X509 *KOpenSSLProxy::X509_STORE_CTX_get_current_cert(X509_STORE_CTX *v) |
275 |
+{ |
276 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
277 |
+ return v->current_cert; |
278 |
+#else |
279 |
+ if (K_X509_STORE_CTX_get_current_cert) { |
280 |
+ return (K_X509_STORE_CTX_get_current_cert)(v); |
281 |
+ } else { |
282 |
+ return 0L; |
283 |
+ } |
284 |
+#endif |
285 |
+} |
286 |
|
287 |
-STACK* KOpenSSLProxy::sk_dup(STACK *s) { |
288 |
- if (K_sk_dup) return (K_sk_dup)(s); |
289 |
- else return 0L; |
290 |
+void KOpenSSLProxy::X509_STORE_CTX_set_error(X509_STORE_CTX *v, int error) |
291 |
+{ |
292 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
293 |
+ v->error = error; |
294 |
+#else |
295 |
+ if (K_X509_STORE_CTX_set_error) { |
296 |
+ (K_X509_STORE_CTX_set_error)(v, error); |
297 |
+ } |
298 |
+#endif |
299 |
} |
300 |
|
301 |
+int KOpenSSLProxy::X509_STORE_CTX_get_error(X509_STORE_CTX *v) |
302 |
+{ |
303 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
304 |
+ return v->error; |
305 |
+#else |
306 |
+ if (K_X509_STORE_CTX_get_error) { |
307 |
+ return (K_X509_STORE_CTX_get_error)(v); |
308 |
+ } else { |
309 |
+ return 0; |
310 |
+ } |
311 |
+#endif |
312 |
+} |
313 |
|
314 |
-STACK* KOpenSSLProxy::sk_new(int (*cmp)()) { |
315 |
- if (K_sk_new) return (K_sk_new)(cmp); |
316 |
+STACK *KOpenSSLProxy::OPENSSL_sk_dup(STACK *s) |
317 |
+{ |
318 |
+ if (K_OPENSSL_sk_dup) return (K_OPENSSL_sk_dup)(s); |
319 |
+ else return 0L; |
320 |
+} |
321 |
+ |
322 |
+STACK* KOpenSSLProxy::OPENSSL_sk_new(int (*cmp)()) { |
323 |
+ if (K_OPENSSL_sk_new) return (K_OPENSSL_sk_new)(cmp); |
324 |
else return 0L; |
325 |
} |
326 |
|
327 |
|
328 |
-int KOpenSSLProxy::sk_push(STACK* s, char* d) { |
329 |
- if (K_sk_push) return (K_sk_push)(s,d); |
330 |
+int KOpenSSLProxy::OPENSSL_sk_push(STACK* s, char* d) { |
331 |
+ if (K_OPENSSL_sk_push) return (K_OPENSSL_sk_push)(s,d); |
332 |
else return -1; |
333 |
} |
334 |
|
335 |
@@ -1423,6 +1561,98 @@ int KOpenSSLProxy::EVP_PKEY_assign(EVP_P |
336 |
else return -1; |
337 |
} |
338 |
|
339 |
+int KOpenSSLProxy::EVP_PKEY_base_id(EVP_PKEY *pkey) |
340 |
+{ |
341 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
342 |
+ return pkey->type; |
343 |
+#else |
344 |
+ if (K_EVP_PKEY_base_id) { |
345 |
+ return (K_EVP_PKEY_base_id)(pkey); |
346 |
+ } else { |
347 |
+ return 0; |
348 |
+ } |
349 |
+#endif |
350 |
+} |
351 |
+ |
352 |
+RSA *KOpenSSLProxy::EVP_PKEY_get0_RSA(EVP_PKEY *pkey) |
353 |
+{ |
354 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
355 |
+ return pkey->pkey.rsa; |
356 |
+#else |
357 |
+ if (K_EVP_PKEY_get0_RSA) { |
358 |
+ return (K_EVP_PKEY_get0_RSA)(pkey); |
359 |
+ } else { |
360 |
+ return nullptr; |
361 |
+ } |
362 |
+#endif |
363 |
+} |
364 |
+ |
365 |
+void KOpenSSLProxy::RSA_get0_key(RSA *rsa, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d) |
366 |
+{ |
367 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
368 |
+ if (n) { |
369 |
+ *n = rsa->n; |
370 |
+ } |
371 |
+ if (e) { |
372 |
+ *e = rsa->e; |
373 |
+ } |
374 |
+ if (d) { |
375 |
+ *d = rsa->d; |
376 |
+ } |
377 |
+#else |
378 |
+ if (K_RSA_get0_key) { |
379 |
+ (K_RSA_get0_key)(rsa, n, e, d); |
380 |
+ } |
381 |
+#endif |
382 |
+} |
383 |
+ |
384 |
+DSA *KOpenSSLProxy::EVP_PKEY_get0_DSA(EVP_PKEY *pkey) |
385 |
+{ |
386 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
387 |
+ return pkey->pkey.dsa; |
388 |
+#else |
389 |
+ if (K_EVP_PKEY_get0_DSA) { |
390 |
+ return (K_EVP_PKEY_get0_DSA)(pkey); |
391 |
+ } else { |
392 |
+ return 0L; |
393 |
+ } |
394 |
+#endif |
395 |
+} |
396 |
+ |
397 |
+void KOpenSSLProxy::DSA_get0_pqg(DSA *dsa, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g) |
398 |
+{ |
399 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
400 |
+ if (p) { |
401 |
+ *p = dsa->p; |
402 |
+ } |
403 |
+ if (q) { |
404 |
+ *q = dsa->q; |
405 |
+ } |
406 |
+ if (g) { |
407 |
+ *g = dsa->g; |
408 |
+ } |
409 |
+#else |
410 |
+ if (K_DSA_get0_pqg) { |
411 |
+ (K_DSA_get0_pqg)(dsa, p, q, g); |
412 |
+ } |
413 |
+#endif |
414 |
+} |
415 |
+ |
416 |
+void KOpenSSLProxy::DSA_get0_key(DSA *dsa, const BIGNUM **pub_key, const BIGNUM **priv_key) |
417 |
+{ |
418 |
+#if OPENSSL_VERSION_NUMBER < 0x10100000L |
419 |
+ if (pub_key) { |
420 |
+ *pub_key = dsa->pub_key; |
421 |
+ } |
422 |
+ if (priv_key) { |
423 |
+ *priv_key = dsa->priv_key; |
424 |
+ } |
425 |
+#else |
426 |
+ if (K_DSA_get0_key) { |
427 |
+ (K_DSA_get0_key)(dsa, pub_key, priv_key); |
428 |
+ } |
429 |
+#endif |
430 |
+} |
431 |
|
432 |
int KOpenSSLProxy::X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey) { |
433 |
if (K_X509_REQ_set_pubkey) return (K_X509_REQ_set_pubkey)(x, pkey); |