View | Details | Raw Unified | Return to bug 233182
Collapse All | Expand All

(-)files/patch-kio_kssl_kopenssl.cpp (+433 lines)
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);
(-)files/patch-kio_kssl_kopenssl.h (+155 lines)
Line 0 Link Here
1
--- kio/kssl/kopenssl.h.orig	2018-11-13 17:02:46 UTC
2
+++ kio/kssl/kopenssl.h
3
@@ -295,6 +295,15 @@ public:
4
     */
5
    X509 *X509_dup(X509 *x509);
6
 
7
+   /*
8
+    *   X509_getm_notBefore - get validity start
9
+    */
10
+   ASN1_TIME *X509_getm_notBefore(const X509 *x);
11
+
12
+   /*
13
+    *   X509_getm_notAfter - get validity end
14
+    */
15
+   ASN1_TIME *X509_getm_notAfter(const X509 *x);
16
 
17
    /*
18
     *   X509_STORE_CTX_new - create an X509 store context
19
@@ -318,6 +327,21 @@ public:
20
     */
21
    void X509_STORE_CTX_set_purpose(X509_STORE_CTX *v, int purpose);
22
 
23
+   /**
24
+    *   X509_STORE_CTX_get_current_cert - get the current certificate
25
+    */
26
+   X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *v);
27
+
28
+   /**
29
+    *   X509_STORE_CTX_set_error - set certificate error
30
+    */
31
+   void X509_STORE_CTX_set_error(X509_STORE_CTX *v, int error);
32
+
33
+   /**
34
+    *   X509_STORE_CTX_get_error - get certificate error
35
+    */
36
+   int X509_STORE_CTX_get_error(X509_STORE_CTX *v);
37
+
38
    /*
39
     *   X509_verify_cert - verify the certificate
40
     */
41
@@ -335,6 +359,10 @@ public:
42
     */
43
    void X509_STORE_free(X509_STORE *v);
44
 
45
+   /*
46
+    *   X509_STORE_set_verify_cb - set verify callback
47
+    */
48
+   void X509_STORE_set_verify_cb(X509_STORE *v, int (*verify_cb)(int, X509_STORE_CTX *));
49
 
50
    /*
51
     *   X509_free - free up an X509
52
@@ -359,6 +387,10 @@ public:
53
     */
54
    X509_NAME *X509_get_issuer_name(X509 *a);
55
 
56
+   /*
57
+    *   X509_get0_signature - return X509 signature and signature algorithm
58
+    */
59
+   void X509_get0_signature(const ASN1_BIT_STRING **psig, const X509_ALGOR **palg, const X509 *x);
60
 
61
    /*
62
     *   X509_STORE_add_lookup - add a lookup file/method to an X509 store
63
@@ -393,7 +425,11 @@ public:
64
    /*
65
     *   CRYPTO_free - free up an internally allocated object
66
     */
67
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
68
    void CRYPTO_free(void *x);
69
+#else
70
+   void CRYPTO_free(void *x, const char *file, int line);
71
+#endif
72
 
73
    /*
74
     *   BIO_new - create new BIO
75
@@ -505,53 +541,53 @@ public:
76
    /*
77
     *   Pop off the stack
78
     */
79
-   char *sk_pop(STACK *s);
80
+   char *OPENSSL_sk_pop(STACK *s);
81
 
82
 
83
    /*
84
     *   Free the stack
85
     */
86
-   void sk_free(STACK *s);
87
+   void OPENSSL_sk_free(STACK *s);
88
 
89
 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
90
-   void sk_free(void *s) { return sk_free(reinterpret_cast<STACK*>(s)); }
91
+   void OPENSSL_sk_free(void *s) { return OPENSSL_sk_free(reinterpret_cast<STACK*>(s)); }
92
 #endif
93
 
94
    /*
95
     *  Number of elements in the stack
96
     */
97
-   int sk_num(STACK *s);
98
+   int OPENSSL_sk_num(STACK *s);
99
 
100
 
101
    /*
102
     *  Value of element n in the stack
103
     */
104
-   char *sk_value(STACK *s, int n);
105
+   char *OPENSSL_sk_value(STACK *s, int n);
106
 
107
 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
108
-   char *sk_value(void *s, int n) { return sk_value(reinterpret_cast<STACK*>(s), n); }
109
+   char *OPENSSL_sk_value(void *s, int n) { return OPENSSL_sk_value(reinterpret_cast<STACK*>(s), n); }
110
 #endif
111
 
112
    /*
113
     *  Create a new stack
114
     */
115
-   STACK *sk_new(int (*cmp)());
116
+   STACK *OPENSSL_sk_new(int (*cmp)());
117
 
118
 
119
    /*
120
     *  Add an element to the stack
121
     */
122
-   int sk_push(STACK *s, char *d);
123
+   int OPENSSL_sk_push(STACK *s, char *d);
124
 
125
 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
126
-   int sk_push(void *s, void *d) { return sk_push(reinterpret_cast<STACK*>(s), reinterpret_cast<char*>(d)); }
127
+   int OPENSSL_sk_push(void *s, void *d) { return OPENSSL_sk_push(reinterpret_cast<STACK*>(s), reinterpret_cast<char*>(d)); }
128
 #endif
129
 
130
 
131
    /*
132
     *  Duplicate the stack
133
     */
134
-   STACK *sk_dup(STACK *s);
135
+   STACK *OPENSSL_sk_dup(STACK *s);
136
 
137
 
138
    /*
139
@@ -798,6 +834,16 @@ public:
140
     */
141
    int EVP_PKEY_assign(EVP_PKEY *pkey, int type, char *key);
142
 
143
+   /*
144
+    * Get key type
145
+    */
146
+   int EVP_PKEY_base_id(EVP_PKEY *pkey);
147
+
148
+   RSA *EVP_PKEY_get0_RSA(EVP_PKEY *pkey);
149
+   void RSA_get0_key(RSA *rsa, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d);
150
+   DSA *EVP_PKEY_get0_DSA(EVP_PKEY *pkey);
151
+   void DSA_get0_pqg(DSA *dsa, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g);
152
+   void DSA_get0_key(DSA *dsa, const BIGNUM **pub_key, const BIGNUM **priv_key);
153
 
154
    /*
155
     * Generate a RSA key
(-)files/patch-kio_kssl_kssl.cpp (+17 lines)
Line 0 Link Here
1
--- kio/kssl/kssl.cpp.orig	2018-11-13 17:03:15 UTC
2
+++ kio/kssl/kssl.cpp
3
@@ -55,8 +55,6 @@
4
 #warning "kssl.cc needs to be ported to QSslSocket"
5
 #endif
6
 
7
-#define sk_dup d->kossl->sk_dup
8
-
9
 class KSSLPrivate {
10
 public:
11
 	KSSLPrivate() {
12
@@ -212,5 +210,3 @@ bool KSSL::doesSSLWork() {
13
 	return m_bSSLWorks;
14
 }
15
 
16
-#undef sk_dup
17
-
(-)files/patch-kio_kssl_ksslcallback.c (+19 lines)
Line 0 Link Here
1
--- kio/kssl/ksslcallback.c.orig	2018-11-13 17:03:28 UTC
2
+++ kio/kssl/ksslcallback.c
3
@@ -39,14 +39,14 @@ static int X509Callback(int ok, X509_STO
4
 
5
   if (KSSL_X509CallBack_ca)
6
   {
7
-     if (KOSSL::self()->X509_cmp(ctx->current_cert, KSSL_X509CallBack_ca) != 0)
8
+     if (KOSSL::self()->X509_cmp(KOSSL::self()->X509_STORE_CTX_get_current_cert(ctx), KSSL_X509CallBack_ca) != 0)
9
         return 1; // Ignore errors for this certificate
10
 
11
      KSSL_X509CallBack_ca_found = true;
12
   }
13
  
14
   if (!ok) {
15
-    switch (ctx->error) {
16
+    switch (KOSSL::self()->X509_STORE_CTX_get_error(ctx)) {
17
       case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
18
       case X509_V_ERR_UNABLE_TO_GET_CRL:
19
       case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
(-)files/patch-kio_kssl_ksslcertchain.cpp (+121 lines)
Line 0 Link Here
1
--- kio/kssl/ksslcertchain.cpp.orig	2018-11-13 17:03:41 UTC
2
+++ kio/kssl/ksslcertchain.cpp
3
@@ -44,16 +44,6 @@
4
 #include <kdebug.h>
5
 #include <QtCore/QStringList>
6
 
7
-#ifdef KSSL_HAVE_SSL
8
-#define sk_new d->kossl->sk_new
9
-#define sk_push d->kossl->sk_push
10
-#define sk_free d->kossl->sk_free
11
-#define sk_value d->kossl->sk_value
12
-#define sk_num d->kossl->sk_num
13
-#define sk_dup d->kossl->sk_dup
14
-#define sk_pop d->kossl->sk_pop
15
-#endif
16
-
17
 class KSSLCertChainPrivate {
18
 public:
19
   KSSLCertChainPrivate() {
20
@@ -79,11 +69,11 @@ KSSLCertChain::~KSSLCertChain() {
21
     STACK_OF(X509) *x = (STACK_OF(X509) *)_chain;
22
 
23
     for (;;) {
24
-      X509* x5 = sk_X509_pop(x);
25
+      X509* x5 = reinterpret_cast<X509*>(d->kossl->OPENSSL_sk_pop(reinterpret_cast<STACK *>(x)));
26
       if (!x5) break;
27
       d->kossl->X509_free(x5);
28
     }
29
-    sk_X509_free(x);
30
+    d->kossl->OPENSSL_sk_free(reinterpret_cast<STACK *>(x));
31
   }
32
 #endif
33
   delete d;
34
@@ -106,7 +96,7 @@ KSSLCertChain *KSSLCertChain::replicate(
35
 
36
 int KSSLCertChain::depth() {
37
 #ifdef KSSL_HAVE_SSL
38
-  return sk_X509_num((STACK_OF(X509)*)_chain);
39
+  return d->kossl->OPENSSL_sk_num(static_cast<STACK *>(_chain));
40
 #endif
41
 return 0;
42
 }
43
@@ -123,8 +113,8 @@ QList<KSSLCertificate *> KSSLCertChain::
44
 #ifdef KSSL_HAVE_SSL
45
     STACK_OF(X509) *x = (STACK_OF(X509) *)_chain;
46
 
47
-   for (int i = 0; i < sk_X509_num(x); i++) {
48
-     X509* x5 = sk_X509_value(x, i);
49
+   for (int i = 0; i < d->kossl->OPENSSL_sk_num(reinterpret_cast<STACK *>(x)); i++) {
50
+     X509* x5 = reinterpret_cast<X509*>(d->kossl->OPENSSL_sk_value(reinterpret_cast<STACK *>(x), i));
51
      if (!x5) continue;
52
      KSSLCertificate *nc = new KSSLCertificate;
53
      nc->setCert(d->kossl->X509_dup(x5));
54
@@ -142,18 +132,18 @@ void KSSLCertChain::setChain(const QList
55
         STACK_OF(X509) *x = (STACK_OF(X509) *)_chain;
56
 
57
         for (;;) {
58
-            X509* x5 = sk_X509_pop(x);
59
+            X509* x5 = reinterpret_cast<X509*>(d->kossl->OPENSSL_sk_pop(reinterpret_cast<STACK*>(x)));
60
             if (!x5) break;
61
             d->kossl->X509_free(x5);
62
         }
63
-        sk_X509_free(x);
64
+        d->kossl->OPENSSL_sk_free(reinterpret_cast<STACK*>(x));
65
         _chain = NULL;
66
     }
67
 
68
     if (chain.isEmpty()) return;
69
-    _chain = (void *)sk_new(NULL);
70
+    _chain = (void *)d->kossl->OPENSSL_sk_new(NULL);
71
     foreach (KSSLCertificate *x, chain) {
72
-        sk_X509_push((STACK_OF(X509)*)_chain, d->kossl->X509_dup(x->getCert()));
73
+        d->kossl->OPENSSL_sk_push(static_cast<STACK*>(_chain), d->kossl->X509_dup(x->getCert()));
74
     }
75
 
76
 #endif
77
@@ -166,23 +156,23 @@ if (_chain) {
78
     STACK_OF(X509) *x = (STACK_OF(X509) *)_chain;
79
 
80
     for (;;) {
81
-      X509* x5 = sk_X509_pop(x);
82
+      X509* x5 = reinterpret_cast<X509 *>(d->kossl->OPENSSL_sk_pop(reinterpret_cast<STACK *>(x)));
83
       if (!x5) break;
84
       d->kossl->X509_free(x5);
85
     }
86
-    sk_X509_free(x);
87
+    d->kossl->OPENSSL_sk_free(reinterpret_cast<STACK *>(x));
88
     _chain = NULL;
89
 }
90
 
91
 if (!stack_of_x509) return;
92
 
93
-_chain = (void *)sk_new(NULL);
94
+_chain = (void *)d->kossl->OPENSSL_sk_new(NULL);
95
 STACK_OF(X509) *x = (STACK_OF(X509) *)stack_of_x509;
96
 
97
-   for (int i = 0; i < sk_X509_num(x); i++) {
98
-     X509* x5 = sk_X509_value(x, i);
99
+   for (int i = 0; i < d->kossl->OPENSSL_sk_num(reinterpret_cast<STACK *>(x)); i++) {
100
+     X509* x5 = reinterpret_cast<X509*>(d->kossl->OPENSSL_sk_value(reinterpret_cast<STACK *>(x), i));
101
      if (!x5) continue;
102
-     sk_X509_push((STACK_OF(X509)*)_chain,d->kossl->X509_dup(x5));
103
+     d->kossl->OPENSSL_sk_push(reinterpret_cast<STACK *>(_chain), d->kossl->X509_dup(x5));
104
    }
105
 
106
 #else
107
@@ -202,14 +192,3 @@ void KSSLCertChain::setCertChain(const Q
108
     setChain(cl);
109
 }
110
 
111
-
112
-#ifdef KSSL_HAVE_SSL
113
-#undef sk_new
114
-#undef sk_push
115
-#undef sk_free
116
-#undef sk_value
117
-#undef sk_num
118
-#undef sk_dup
119
-#undef sk_pop
120
-#endif
121
-
(-)files/patch-kio_kssl_ksslcertificate.cpp (+289 lines)
Line 0 Link Here
1
--- kio/kssl/ksslcertificate.cpp.orig	2018-11-13 17:03:57 UTC
2
+++ kio/kssl/ksslcertificate.cpp
3
@@ -173,7 +173,11 @@ QString KSSLCertificate::getSubject() co
4
         return rc;
5
     }
6
     rc = t;
7
-    d->kossl->OPENSSL_free(t);
8
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
9
+    d->kossl->CRYPTO_free(t);
10
+#else
11
+    d->kossl->CRYPTO_free(t, __FILE__, __LINE__);
12
+#endif
13
 #endif
14
     return rc;
15
 }
16
@@ -200,14 +204,17 @@ QString KSSLCertificate::getSignatureTex
17
     char *s;
18
     int n, i;
19
 
20
-    i = d->kossl->OBJ_obj2nid(d->m_cert->sig_alg->algorithm);
21
+    const X509_ALGOR *algor;
22
+    const ASN1_BIT_STRING *sig;
23
+    d->kossl->X509_get0_signature(&sig, &algor, d->m_cert);
24
+    i = d->kossl->OBJ_obj2nid(algor->algorithm);
25
     rc = i18n("Signature Algorithm: ");
26
     rc += (i == NID_undef)?i18n("Unknown"):QString(d->kossl->OBJ_nid2ln(i));
27
 
28
     rc += '\n';
29
     rc += i18n("Signature Contents:");
30
-    n = d->m_cert->signature->length;
31
-    s = (char *)d->m_cert->signature->data;
32
+    n = sig->length;
33
+    s = (char *)sig->data;
34
     for (i = 0; i < n; ++i) {
35
         if (i%20 != 0) {
36
             rc += ':';
37
@@ -233,9 +240,10 @@ void KSSLCertificate::getEmails(QStringL
38
     }
39
 
40
     STACK *s = d->kossl->X509_get1_email(d->m_cert);
41
+    const int size = d->kossl->OPENSSL_sk_num(s);
42
     if (s) {
43
-        for(int n=0; n < s->num; n++) {
44
-            to.append(d->kossl->sk_value(s,n));
45
+        for(int n=0; n < size; n++) {
46
+            to.append(d->kossl->OPENSSL_sk_value(s,n));
47
         }
48
         d->kossl->X509_email_free(s);
49
     }
50
@@ -317,13 +325,13 @@ QString rc = "";
51
     EVP_PKEY *pkey = d->kossl->X509_get_pubkey(d->m_cert);
52
     if (pkey) {
53
         #ifndef NO_RSA
54
-            if (pkey->type == EVP_PKEY_RSA) {
55
+            if (d->kossl->EVP_PKEY_base_id(pkey) == EVP_PKEY_RSA) {
56
                 rc = "RSA";
57
             }
58
             else
59
         #endif
60
         #ifndef NO_DSA
61
-            if (pkey->type == EVP_PKEY_DSA) {
62
+            if (d->kossl->EVP_PKEY_base_id(pkey) == EVP_PKEY_DSA) {
63
                 rc = "DSA";
64
             }
65
             else
66
@@ -347,8 +355,10 @@ char *x = NULL;
67
     if (pkey) {
68
         rc = i18nc("Unknown", "Unknown key algorithm");
69
         #ifndef NO_RSA
70
-            if (pkey->type == EVP_PKEY_RSA) {
71
-                x = d->kossl->BN_bn2hex(pkey->pkey.rsa->n);
72
+            if (d->kossl->EVP_PKEY_base_id(pkey) == EVP_PKEY_RSA) {
73
+                const BIGNUM *n, *e;
74
+                d->kossl->RSA_get0_key(d->kossl->EVP_PKEY_get0_RSA(pkey), &n, &e, nullptr);
75
+                x = d->kossl->BN_bn2hex(n);
76
                 rc = i18n("Key type: RSA (%1 bit)", strlen(x)*4) + '\n';
77
 
78
                 rc += i18n("Modulus: ");
79
@@ -362,17 +372,28 @@ char *x = NULL;
80
                     rc += x[i];
81
                 }
82
                 rc += '\n';
83
-                d->kossl->OPENSSL_free(x);
84
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
85
+                d->kossl->CRYPTO_free(x);
86
+#else
87
+                d->kossl->CRYPTO_free(x, __FILE__, __LINE__);
88
+#endif
89
 
90
-                x = d->kossl->BN_bn2hex(pkey->pkey.rsa->e);
91
+                x = d->kossl->BN_bn2hex(e);
92
                 rc += i18n("Exponent: 0x") + QLatin1String(x) +
93
                   QLatin1String("\n");
94
-                d->kossl->OPENSSL_free(x);
95
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
96
+                d->kossl->CRYPTO_free(x);
97
+#else
98
+                d->kossl->CRYPTO_free(x, __FILE__, __LINE__);
99
+#endif
100
             }
101
         #endif
102
         #ifndef NO_DSA
103
-            if (pkey->type == EVP_PKEY_DSA) {
104
-                x = d->kossl->BN_bn2hex(pkey->pkey.dsa->p);
105
+            if (d->kossl->EVP_PKEY_base_id(pkey) == EVP_PKEY_DSA) {
106
+                auto dsa = d->kossl->EVP_PKEY_get0_DSA(pkey);
107
+                const BIGNUM *p, *q, *g;
108
+                d->kossl->DSA_get0_pqg(dsa, &p, &q, &g);
109
+                x = d->kossl->BN_bn2hex(p);
110
                 // hack - this may not be always accurate
111
                 rc = i18n("Key type: DSA (%1 bit)", strlen(x)*4) + '\n';
112
 
113
@@ -387,9 +408,13 @@ char *x = NULL;
114
                     rc += x[i];
115
                 }
116
                 rc += '\n';
117
-                d->kossl->OPENSSL_free(x);
118
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
119
+                d->kossl->CRYPTO_free(x);
120
+#else
121
+                d->kossl->CRYPTO_free(x, __FILE__, __LINE__);
122
+#endif
123
 
124
-                x = d->kossl->BN_bn2hex(pkey->pkey.dsa->q);
125
+                x = d->kossl->BN_bn2hex(q);
126
                 rc += i18n("160 bit prime factor: ");
127
                 for (unsigned int i = 0; i < strlen(x); i++) {
128
                     if (i%40 != 0 && i%2 == 0) {
129
@@ -401,9 +426,13 @@ char *x = NULL;
130
                     rc += x[i];
131
                 }
132
                 rc += '\n';
133
-                d->kossl->OPENSSL_free(x);
134
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
135
+                d->kossl->CRYPTO_free(x);
136
+#else
137
+                d->kossl->CRYPTO_free(x, __FILE__, __LINE__);
138
+#endif
139
 
140
-                x = d->kossl->BN_bn2hex(pkey->pkey.dsa->g);
141
+                x = d->kossl->BN_bn2hex(g);
142
                 rc += QString("g: ");
143
                 for (unsigned int i = 0; i < strlen(x); i++) {
144
                     if (i%40 != 0 && i%2 == 0) {
145
@@ -415,9 +444,15 @@ char *x = NULL;
146
                     rc += x[i];
147
                 }
148
                 rc += '\n';
149
-                d->kossl->OPENSSL_free(x);
150
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
151
+                d->kossl->CRYPTO_free(x);
152
+#else
153
+                d->kossl->CRYPTO_free(x, __FILE__, __LINE__);
154
+#endif
155
 
156
-                x = d->kossl->BN_bn2hex(pkey->pkey.dsa->pub_key);
157
+                const BIGNUM *pub_key;
158
+                d->kossl->DSA_get0_key(dsa, &pub_key, nullptr);
159
+                x = d->kossl->BN_bn2hex(pub_key);
160
                 rc += i18n("Public key: ");
161
                 for (unsigned int i = 0; i < strlen(x); i++) {
162
                     if (i%40 != 0 && i%2 == 0) {
163
@@ -429,7 +464,11 @@ char *x = NULL;
164
                     rc += x[i];
165
                 }
166
                 rc += '\n';
167
-                d->kossl->OPENSSL_free(x);
168
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
169
+                d->kossl->CRYPTO_free(x);
170
+#else
171
+                d->kossl->CRYPTO_free(x, __FILE__, __LINE__);
172
+#endif
173
             }
174
         #endif
175
         d->kossl->EVP_PKEY_free(pkey);
176
@@ -452,7 +491,11 @@ QString rc = "";
177
     }
178
 
179
     rc = t;
180
-    d->kossl->OPENSSL_free(t);
181
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
182
+    d->kossl->CRYPTO_free(t);
183
+#else
184
+    d->kossl->CRYPTO_free(t, __FILE__, __LINE__);
185
+#endif
186
 #endif
187
 
188
     return rc;
189
@@ -682,7 +725,7 @@ KSSLCertificate::KSSLValidationList KSSL
190
             return errors;
191
         }
192
 
193
-        X509_STORE_set_verify_cb_func(certStore, X509Callback);
194
+        d->kossl->X509_STORE_set_verify_cb(certStore, X509Callback);
195
 
196
         certLookup = d->kossl->X509_STORE_add_lookup(certStore, d->kossl->X509_LOOKUP_file());
197
         if (!certLookup) {
198
@@ -724,9 +767,9 @@ KSSLCertificate::KSSLValidationList KSSL
199
         KSSL_X509CallBack_ca = ca ? ca->d->m_cert : 0;
200
         KSSL_X509CallBack_ca_found = false;
201
 
202
-        certStoreCTX->error = X509_V_OK;
203
+        d->kossl->X509_STORE_CTX_set_error(certStoreCTX, X509_V_OK);
204
         rc = d->kossl->X509_verify_cert(certStoreCTX);
205
-        int errcode = certStoreCTX->error;
206
+        int errcode = d->kossl->X509_STORE_CTX_get_error(certStoreCTX);
207
         if (ca && !KSSL_X509CallBack_ca_found) {
208
             ksslv = KSSLCertificate::Irrelevant;
209
         } else {
210
@@ -739,9 +782,9 @@ KSSLCertificate::KSSLValidationList KSSL
211
             d->kossl->X509_STORE_CTX_set_purpose(certStoreCTX,
212
                                                  X509_PURPOSE_NS_SSL_SERVER);
213
 
214
-            certStoreCTX->error = X509_V_OK;
215
+            d->kossl->X509_STORE_CTX_set_error(certStoreCTX, X509_V_OK);
216
             rc = d->kossl->X509_verify_cert(certStoreCTX);
217
-            errcode = certStoreCTX->error;
218
+            errcode = d->kossl->X509_STORE_CTX_get_error(certStoreCTX);
219
             ksslv = processError(errcode);
220
         }
221
         d->kossl->X509_STORE_CTX_free(certStoreCTX);
222
@@ -978,7 +1021,7 @@ KSSLCertificate::KSSLValidation KSSLCert
223
 
224
 QString KSSLCertificate::getNotBefore() const {
225
 #ifdef KSSL_HAVE_SSL
226
-    return ASN1_UTCTIME_QString(X509_get_notBefore(d->m_cert));
227
+    return ASN1_UTCTIME_QString(d->kossl->X509_getm_notBefore(d->m_cert));
228
 #else
229
     return QString();
230
 #endif
231
@@ -987,7 +1030,7 @@ QString KSSLCertificate::getNotBefore() 
232
 
233
 QString KSSLCertificate::getNotAfter() const {
234
 #ifdef KSSL_HAVE_SSL
235
-    return ASN1_UTCTIME_QString(X509_get_notAfter(d->m_cert));
236
+    return ASN1_UTCTIME_QString(d->kossl->X509_getm_notAfter(d->m_cert));
237
 #else
238
     return QString();
239
 #endif
240
@@ -996,7 +1039,7 @@ QString KSSLCertificate::getNotAfter() c
241
 
242
 QDateTime KSSLCertificate::getQDTNotBefore() const {
243
 #ifdef KSSL_HAVE_SSL
244
-    return ASN1_UTCTIME_QDateTime(X509_get_notBefore(d->m_cert), NULL);
245
+    return ASN1_UTCTIME_QDateTime(d->kossl->X509_getm_notBefore(d->m_cert), NULL);
246
 #else
247
     return QDateTime::currentDateTime();
248
 #endif
249
@@ -1005,7 +1048,7 @@ QDateTime KSSLCertificate::getQDTNotBefo
250
 
251
 QDateTime KSSLCertificate::getQDTNotAfter() const {
252
 #ifdef KSSL_HAVE_SSL
253
-    return ASN1_UTCTIME_QDateTime(X509_get_notAfter(d->m_cert), NULL);
254
+    return ASN1_UTCTIME_QDateTime(d->kossl->X509_getm_notAfter(d->m_cert), NULL);
255
 #else
256
     return QDateTime::currentDateTime();
257
 #endif
258
@@ -1210,7 +1253,8 @@ typedef struct NETSCAPE_X509_st
259
 // what a piece of crap this is
260
 QByteArray KSSLCertificate::toNetscape() {
261
     QByteArray qba;
262
-#ifdef KSSL_HAVE_SSL
263
+    // no equivalent in OpenSSL 1.1.0 (?), so behave as if we had no OpenSSL at all
264
+#if KSSL_HAVE_SSL && OPENSSL_VERSION_NUMBER < 0x10100000L
265
     NETSCAPE_X509 nx;
266
     ASN1_OCTET_STRING hdr;
267
     KTemporaryFile ktf;
268
@@ -1293,10 +1337,10 @@ QStringList KSSLCertificate::subjAltName
269
         return rc;
270
     }
271
 
272
-    int cnt = d->kossl->sk_GENERAL_NAME_num(names);
273
+    int cnt = d->kossl->OPENSSL_sk_num((STACK *)names);
274
 
275
     for (int i = 0; i < cnt; i++) {
276
-        const GENERAL_NAME *val = (const GENERAL_NAME *)d->kossl->sk_value(names, i);
277
+        const GENERAL_NAME *val = (const GENERAL_NAME *)d->kossl->OPENSSL_sk_value(names, i);
278
         if (val->type != GEN_DNS) {
279
             continue;
280
         }
281
@@ -1308,7 +1352,7 @@ QStringList KSSLCertificate::subjAltName
282
             rc += s;
283
         }
284
     }
285
-    d->kossl->sk_free(names);
286
+    d->kossl->OPENSSL_sk_free(names);
287
 #endif
288
     return rc;
289
 }
(-)files/patch-kio_kssl_ksslutils.cpp (+15 lines)
Line 0 Link Here
1
--- kio/kssl/ksslutils.cpp.orig	2018-11-13 23:56:16 UTC
2
+++ kio/kssl/ksslutils.cpp
3
@@ -84,7 +84,11 @@ QString ASN1_UTCTIME_QString(ASN1_UTCTIM
4
 QString ASN1_INTEGER_QString(ASN1_INTEGER *aint) {
5
 char *rep = KOSSL::self()->i2s_ASN1_INTEGER(NULL, aint);
6
 QString yy = rep;
7
-KOSSL::self()->OPENSSL_free(rep);
8
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
9
+KOSSL::self()->CRYPTO_free(rep);
10
+#else
11
+KOSSL::self()->CRYPTO_free(rep, __FILE__, __LINE__);
12
+#endif
13
 return yy;
14
 }
15
 

Return to bug 233182