Annotation of /trunk/m2crypto/patches/m2crypto-0.22.5-no-sslv2.patch
Parent Directory | Revision Log
Revision 2770 -
(hide annotations)
(download)
Fri Mar 4 10:13:47 2016 UTC (8 years, 3 months ago) by niro
File size: 18683 byte(s)
Fri Mar 4 10:13:47 2016 UTC (8 years, 3 months ago) by niro
File size: 18683 byte(s)
-adde no-sslv2 patch
1 | niro | 2770 | Index: tests/test_ssl.py |
2 | =================================================================== | ||
3 | --- tests/test_ssl.py (revision 698) | ||
4 | +++ tests/test_ssl.py (working copy) | ||
5 | @@ -405,8 +405,11 @@ | ||
6 | try: | ||
7 | ctx = SSL.Context('sslv23', weak_crypto=1) | ||
8 | s = SSL.Connection(ctx) | ||
9 | - s.connect(self.srv_addr) | ||
10 | - self.failUnlessEqual(s.get_version(), 'SSLv2') | ||
11 | + if m2.OPENSSL_VERSION_NUMBER < 0x10000000: # SSLv2 ciphers disabled by default in newer OpenSSL | ||
12 | + s.connect(self.srv_addr) | ||
13 | + self.failUnlessEqual(s.get_version(), 'SSLv2') | ||
14 | + else: | ||
15 | + self.assertRaises(SSL.SSLError, s.connect, self.srv_addr) | ||
16 | s.close() | ||
17 | finally: | ||
18 | self.stop_server(pid) | ||
19 | Index: tests/test_x509.py | ||
20 | =================================================================== | ||
21 | --- tests/test_x509.py (revision 698) | ||
22 | +++ tests/test_x509.py (working copy) | ||
23 | @@ -142,7 +142,7 @@ | ||
24 | cn.set_data("Hello There!") | ||
25 | assert cn.get_data().as_text() == "Hello There!", cn.get_data().as_text() | ||
26 | |||
27 | - assert n.as_hash() == 1697185131 | ||
28 | + self.assertEquals(n.as_hash(), 1697185131) | ||
29 | |||
30 | self.assertRaises(IndexError, lambda: n[100]) | ||
31 | self.assert_(n[10]) | ||
32 | Index: tests/test_smime.py | ||
33 | =================================================================== | ||
34 | --- tests/test_smime.py (revision 698) | ||
35 | +++ tests/test_smime.py (working copy) | ||
36 | @@ -6,7 +6,7 @@ | ||
37 | """ | ||
38 | |||
39 | import unittest | ||
40 | -from M2Crypto import SMIME, BIO, Rand, X509, EVP | ||
41 | +from M2Crypto import SMIME, BIO, Rand, X509, EVP, Err | ||
42 | |||
43 | class SMIMETestCase(unittest.TestCase): | ||
44 | cleartext = 'some text to manipulate' | ||
45 | @@ -213,7 +213,7 @@ | ||
46 | |||
47 | self.filenameSmime = 'tests/sig.p7s' | ||
48 | f = BIO.openfile(self.filenameSmime, 'wb') | ||
49 | - assert s.write(f, p7, BIO.MemoryBuffer('some text')) == 1 | ||
50 | + assert s.write(f, p7, BIO.MemoryBuffer('some text')) == 1, Err.get_error() | ||
51 | f.close() | ||
52 | |||
53 | def test_write_pkcs7_der(self): | ||
54 | Index: SWIG/_evp.i | ||
55 | =================================================================== | ||
56 | --- SWIG/_evp.i (revision 695) | ||
57 | +++ SWIG/_evp.i (working copy) | ||
58 | @@ -180,7 +180,7 @@ | ||
59 | |||
60 | PKCS5_PBKDF2_HMAC_SHA1(passbuf, passlen, saltbuf, saltlen, iter, | ||
61 | keylen, key); | ||
62 | - ret = PyString_FromStringAndSize(key, keylen); | ||
63 | + ret = PyString_FromStringAndSize((char*)key, keylen); | ||
64 | OPENSSL_cleanse(key, keylen); | ||
65 | return ret; | ||
66 | } | ||
67 | @@ -339,7 +339,7 @@ | ||
68 | klen = EVP_BytesToKey(cipher, md, (unsigned char *)sbuf, | ||
69 | (unsigned char *)dbuf, dlen, iter, | ||
70 | key, NULL); /* Since we are not returning IV no need to derive it */ | ||
71 | - ret = PyString_FromStringAndSize(key, klen); | ||
72 | + ret = PyString_FromStringAndSize((char*)key, klen); | ||
73 | return ret; | ||
74 | } | ||
75 | |||
76 | @@ -435,7 +435,7 @@ | ||
77 | PyErr_SetString(_evp_err, ERR_reason_error_string(ERR_get_error())); | ||
78 | return NULL; | ||
79 | } | ||
80 | - ret = PyString_FromStringAndSize(sigbuf, siglen); | ||
81 | + ret = PyString_FromStringAndSize((char*)sigbuf, siglen); | ||
82 | OPENSSL_cleanse(sigbuf, siglen); | ||
83 | OPENSSL_free(sigbuf); | ||
84 | return ret; | ||
85 | @@ -513,7 +513,7 @@ | ||
86 | PyErr_SetString(PyExc_ValueError, "EVP_PKEY as DER failed"); | ||
87 | return NULL; | ||
88 | } | ||
89 | - der = PyString_FromStringAndSize(pp, len); | ||
90 | + der = PyString_FromStringAndSize((char*)pp, len); | ||
91 | OPENSSL_free(pp); | ||
92 | return der; | ||
93 | } | ||
94 | Index: SWIG/_ssl.i | ||
95 | =================================================================== | ||
96 | --- SWIG/_ssl.i (revision 695) | ||
97 | +++ SWIG/_ssl.i (working copy) | ||
98 | @@ -17,13 +17,17 @@ | ||
99 | %apply Pointer NONNULL { SSL_CTX * }; | ||
100 | %apply Pointer NONNULL { SSL * }; | ||
101 | %apply Pointer NONNULL { SSL_CIPHER * }; | ||
102 | -%apply Pointer NONNULL { STACK * }; | ||
103 | +%apply Pointer NONNULL { STACK_OF(SSL_CIPHER) * }; | ||
104 | +%apply Pointer NONNULL { STACK_OF(X509) * }; | ||
105 | %apply Pointer NONNULL { BIO * }; | ||
106 | %apply Pointer NONNULL { DH * }; | ||
107 | %apply Pointer NONNULL { RSA * }; | ||
108 | %apply Pointer NONNULL { EVP_PKEY *}; | ||
109 | %apply Pointer NONNULL { PyObject *pyfunc }; | ||
110 | |||
111 | +%rename(ssl_get_ciphers) SSL_get_ciphers; | ||
112 | +extern STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *ssl); | ||
113 | + | ||
114 | %rename(ssl_get_version) SSL_get_version; | ||
115 | extern const char *SSL_get_version(CONST SSL *); | ||
116 | %rename(ssl_get_error) SSL_get_error; | ||
117 | @@ -668,29 +672,25 @@ | ||
118 | return SSL_CIPHER_get_bits(c, NULL); | ||
119 | } | ||
120 | |||
121 | -STACK *ssl_get_ciphers(SSL *ssl) { | ||
122 | - return (STACK *)SSL_get_ciphers(ssl); | ||
123 | +int sk_ssl_cipher_num(STACK_OF(SSL_CIPHER) *stack) { | ||
124 | + return sk_SSL_CIPHER_num(stack); | ||
125 | } | ||
126 | |||
127 | -int sk_ssl_cipher_num(STACK *stack) { | ||
128 | - return sk_num(stack); | ||
129 | +SSL_CIPHER *sk_ssl_cipher_value(STACK_OF(SSL_CIPHER) *stack, int idx) { | ||
130 | + return sk_SSL_CIPHER_value(stack, idx); | ||
131 | } | ||
132 | |||
133 | -SSL_CIPHER *sk_ssl_cipher_value(STACK *stack, int idx) { | ||
134 | - return (SSL_CIPHER *)sk_value(stack, idx); | ||
135 | +STACK_OF(X509) *ssl_get_peer_cert_chain(SSL *ssl) { | ||
136 | + return SSL_get_peer_cert_chain(ssl); | ||
137 | } | ||
138 | |||
139 | -STACK *ssl_get_peer_cert_chain(SSL *ssl) { | ||
140 | - return (STACK *)SSL_get_peer_cert_chain(ssl); | ||
141 | +int sk_x509_num(STACK_OF(X509) *stack) { | ||
142 | + return sk_X509_num(stack); | ||
143 | } | ||
144 | |||
145 | -int sk_x509_num(STACK *stack) { | ||
146 | - return sk_num(stack); | ||
147 | +X509 *sk_x509_value(STACK_OF(X509) *stack, int idx) { | ||
148 | + return sk_X509_value(stack, idx); | ||
149 | } | ||
150 | - | ||
151 | -X509 *sk_x509_value(STACK *stack, int idx) { | ||
152 | - return (X509 *)sk_value(stack, idx); | ||
153 | -} | ||
154 | %} | ||
155 | |||
156 | %threadallow i2d_ssl_session; | ||
157 | Index: SWIG/_x509.i | ||
158 | =================================================================== | ||
159 | --- SWIG/_x509.i (revision 695) | ||
160 | +++ SWIG/_x509.i (working copy) | ||
161 | @@ -148,8 +148,15 @@ | ||
162 | extern int X509_NAME_print_ex(BIO *, X509_NAME *, int, unsigned long); | ||
163 | %rename(x509_name_print_ex_fp) X509_NAME_print_ex_fp; | ||
164 | extern int X509_NAME_print_ex_fp(FILE *, X509_NAME *, int, unsigned long); | ||
165 | + | ||
166 | +#if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
167 | +%rename(x509_name_hash) X509_NAME_hash_old; | ||
168 | +extern unsigned long X509_NAME_hash_old(X509_NAME *); | ||
169 | +#else | ||
170 | %rename(x509_name_hash) X509_NAME_hash; | ||
171 | extern unsigned long X509_NAME_hash(X509_NAME *); | ||
172 | +#endif | ||
173 | + | ||
174 | %rename(x509_name_get_index_by_nid) X509_NAME_get_index_by_NID; | ||
175 | extern int X509_NAME_get_index_by_NID(X509_NAME *, int, int); | ||
176 | |||
177 | @@ -171,7 +178,7 @@ | ||
178 | if (PyString_Check($input)) { | ||
179 | Py_ssize_t len; | ||
180 | |||
181 | - $1 = PyString_AsString($input); | ||
182 | + $1 = (unsigned char *)PyString_AsString($input); | ||
183 | len = PyString_Size($input); | ||
184 | if (len > INT_MAX) { | ||
185 | PyErr_SetString(PyExc_ValueError, "object too large"); | ||
186 | @@ -184,7 +191,7 @@ | ||
187 | } | ||
188 | } | ||
189 | %rename(x509_name_entry_set_data) X509_NAME_ENTRY_set_data; | ||
190 | -extern int X509_NAME_ENTRY_set_data( X509_NAME_ENTRY *, int, CONST unsigned char *, int); | ||
191 | +extern int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *, int, CONST unsigned char *, int); | ||
192 | %typemap(in) (CONST unsigned char *, int); | ||
193 | |||
194 | %rename(x509_req_new) X509_REQ_new; | ||
195 | @@ -230,7 +237,7 @@ | ||
196 | %rename(x509_store_ctx_free) X509_STORE_CTX_free; | ||
197 | extern void X509_STORE_CTX_free(X509_STORE_CTX *); | ||
198 | %rename(x509_store_ctx_get1_chain) X509_STORE_CTX_get1_chain; | ||
199 | -extern STACK *X509_STORE_CTX_get1_chain(X509_STORE_CTX *); | ||
200 | +extern STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *); | ||
201 | |||
202 | %rename(x509_extension_get_critical) X509_EXTENSION_get_critical; | ||
203 | extern int X509_EXTENSION_get_critical(X509_EXTENSION *); | ||
204 | @@ -348,7 +355,7 @@ | ||
205 | PyErr_SetString(_x509_err, ERR_reason_error_string(ERR_get_error())); | ||
206 | } | ||
207 | else { | ||
208 | - ret = PyString_FromStringAndSize(buf, len); | ||
209 | + ret = PyString_FromStringAndSize((char*)buf, len); | ||
210 | OPENSSL_free(buf); | ||
211 | } | ||
212 | return ret; | ||
213 | @@ -435,12 +442,12 @@ | ||
214 | } | ||
215 | |||
216 | int x509_name_set_by_nid(X509_NAME *name, int nid, PyObject *obj) { | ||
217 | - return X509_NAME_add_entry_by_NID(name, nid, MBSTRING_ASC, PyString_AsString(obj), -1, -1, 0); | ||
218 | + return X509_NAME_add_entry_by_NID(name, nid, MBSTRING_ASC, (unsigned char *)PyString_AsString(obj), -1, -1, 0); | ||
219 | } | ||
220 | |||
221 | /* x509_name_add_entry_by_txt */ | ||
222 | int x509_name_add_entry_by_txt(X509_NAME *name, char *field, int type, char *bytes, int len, int loc, int set) { | ||
223 | - return X509_NAME_add_entry_by_txt(name, field, type, bytes, len, loc, set); | ||
224 | + return X509_NAME_add_entry_by_txt(name, field, type, (unsigned char *)bytes, len, loc, set); | ||
225 | } | ||
226 | |||
227 | PyObject *x509_name_get_der(X509_NAME *name) | ||
228 | @@ -450,23 +457,23 @@ | ||
229 | } | ||
230 | |||
231 | /* sk_X509_new_null() is a macro returning "STACK_OF(X509) *". */ | ||
232 | -STACK *sk_x509_new_null(void) { | ||
233 | - return (STACK *)sk_X509_new_null(); | ||
234 | +STACK_OF(X509) *sk_x509_new_null(void) { | ||
235 | + return sk_X509_new_null(); | ||
236 | } | ||
237 | |||
238 | /* sk_X509_free() is a macro. */ | ||
239 | -void sk_x509_free(STACK *stack) { | ||
240 | - sk_X509_free((STACK_OF(X509) *)stack); | ||
241 | +void sk_x509_free(STACK_OF(X509) *stack) { | ||
242 | + sk_X509_free(stack); | ||
243 | } | ||
244 | |||
245 | /* sk_X509_push() is a macro. */ | ||
246 | -int sk_x509_push(STACK *stack, X509 *x509) { | ||
247 | - return sk_X509_push((STACK_OF(X509) *)stack, x509); | ||
248 | +int sk_x509_push(STACK_OF(X509) *stack, X509 *x509) { | ||
249 | + return sk_X509_push(stack, x509); | ||
250 | } | ||
251 | |||
252 | /* sk_X509_pop() is a macro. */ | ||
253 | -X509 *sk_x509_pop(STACK *stack) { | ||
254 | - return sk_X509_pop((STACK_OF(X509) *)stack); | ||
255 | +X509 *sk_x509_pop(STACK_OF(X509) *stack) { | ||
256 | + return sk_X509_pop(stack); | ||
257 | } | ||
258 | |||
259 | int x509_store_load_locations(X509_STORE *store, const char *file) { | ||
260 | @@ -493,21 +500,29 @@ | ||
261 | return X509_REQ_set_version(x, version); | ||
262 | } | ||
263 | |||
264 | -int x509_req_add_extensions(X509_REQ *req, STACK *exts) { | ||
265 | - return X509_REQ_add_extensions(req, (STACK_OF(X509_EXTENSION) *)exts); | ||
266 | +int x509_req_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts) { | ||
267 | + return X509_REQ_add_extensions(req, exts); | ||
268 | } | ||
269 | |||
270 | -X509_NAME_ENTRY *x509_name_entry_create_by_txt( X509_NAME_ENTRY **ne, char *field, int type, char *bytes, int len) { | ||
271 | - return X509_NAME_ENTRY_create_by_txt( ne, field, type, bytes, len); | ||
272 | +X509_NAME_ENTRY *x509_name_entry_create_by_txt(X509_NAME_ENTRY **ne, char *field, int type, char *bytes, int len) { | ||
273 | + return X509_NAME_ENTRY_create_by_txt( ne, field, type, (unsigned char *)bytes, len); | ||
274 | } | ||
275 | |||
276 | -LHASH * | ||
277 | -x509v3_lhash(){ | ||
278 | - return lh_new(NULL,NULL); | ||
279 | +#if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
280 | +LHASH_OF(CONF_VALUE) | ||
281 | +#else | ||
282 | +LHASH | ||
283 | +#endif | ||
284 | +*x509v3_lhash() { | ||
285 | + return lh_new(NULL, NULL); /* Should probably be lh_CONF_VALUE_new but won't compile. */ | ||
286 | } | ||
287 | |||
288 | X509V3_CTX * | ||
289 | -x509v3_set_conf_lhash(LHASH * lhash){ | ||
290 | +#if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
291 | +x509v3_set_conf_lhash(LHASH_OF(CONF_VALUE) * lhash) { | ||
292 | +#else | ||
293 | +x509v3_set_conf_lhash(LHASH * lhash) { | ||
294 | +#endif | ||
295 | X509V3_CTX * ctx; | ||
296 | if (!(ctx=(X509V3_CTX *)PyMem_Malloc(sizeof(X509V3_CTX)))) { | ||
297 | PyErr_SetString(PyExc_MemoryError, "x509v3_set_conf_lhash"); | ||
298 | @@ -517,11 +532,20 @@ | ||
299 | return ctx; | ||
300 | } | ||
301 | |||
302 | -X509_EXTENSION *x509v3_ext_conf(LHASH *conf, X509V3_CTX *ctx, char *name, char *value) { | ||
303 | +X509_EXTENSION * | ||
304 | +#if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
305 | +x509v3_ext_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, char *name, char *value) { | ||
306 | +#else | ||
307 | +x509v3_ext_conf(LHASH *conf, X509V3_CTX *ctx, char *name, char *value) { | ||
308 | +#endif | ||
309 | X509_EXTENSION * ext = NULL; | ||
310 | ext = X509V3_EXT_conf(conf, ctx, name, value); | ||
311 | PyMem_Free(ctx); | ||
312 | +#if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
313 | + lh_CONF_VALUE_free(conf); | ||
314 | +#else | ||
315 | lh_free(conf); | ||
316 | +#endif | ||
317 | return ext; | ||
318 | } | ||
319 | |||
320 | @@ -543,33 +567,33 @@ | ||
321 | } | ||
322 | |||
323 | /* sk_X509_EXTENSION_new_null is a macro. */ | ||
324 | -STACK *sk_x509_extension_new_null(void) { | ||
325 | - return (STACK *)sk_X509_EXTENSION_new_null(); | ||
326 | +STACK_OF(X509_EXTENSION) *sk_x509_extension_new_null(void) { | ||
327 | + return sk_X509_EXTENSION_new_null(); | ||
328 | } | ||
329 | |||
330 | /* sk_X509_EXTENSION_free() is a macro. */ | ||
331 | -void sk_x509_extension_free(STACK *stack) { | ||
332 | - sk_X509_EXTENSION_free((STACK_OF(X509_EXTENSION) *)stack); | ||
333 | +void sk_x509_extension_free(STACK_OF(X509_EXTENSION) *stack) { | ||
334 | + sk_X509_EXTENSION_free(stack); | ||
335 | } | ||
336 | |||
337 | /* sk_X509_EXTENSION_push() is a macro. */ | ||
338 | -int sk_x509_extension_push(STACK *stack, X509_EXTENSION *x509_ext) { | ||
339 | - return sk_X509_EXTENSION_push((STACK_OF(X509_EXTENSION) *)stack, x509_ext); | ||
340 | +int sk_x509_extension_push(STACK_OF(X509_EXTENSION) *stack, X509_EXTENSION *x509_ext) { | ||
341 | + return sk_X509_EXTENSION_push(stack, x509_ext); | ||
342 | } | ||
343 | |||
344 | /* sk_X509_EXTENSION_pop() is a macro. */ | ||
345 | -X509_EXTENSION *sk_x509_extension_pop(STACK *stack) { | ||
346 | - return sk_X509_EXTENSION_pop((STACK_OF(X509_EXTENSION) *)stack); | ||
347 | +X509_EXTENSION *sk_x509_extension_pop(STACK_OF(X509_EXTENSION) *stack) { | ||
348 | + return sk_X509_EXTENSION_pop(stack); | ||
349 | } | ||
350 | |||
351 | /* sk_X509_EXTENSION_num() is a macro. */ | ||
352 | -int sk_x509_extension_num(STACK *stack) { | ||
353 | - return sk_X509_EXTENSION_num((STACK_OF(X509_EXTENSION) *)stack); | ||
354 | +int sk_x509_extension_num(STACK_OF(X509_EXTENSION) *stack) { | ||
355 | + return sk_X509_EXTENSION_num(stack); | ||
356 | } | ||
357 | |||
358 | /* sk_X509_EXTENSION_value() is a macro. */ | ||
359 | -X509_EXTENSION *sk_x509_extension_value(STACK *stack, int i) { | ||
360 | - return sk_X509_EXTENSION_value((STACK_OF(X509_EXTENSION) *)stack, i); | ||
361 | +X509_EXTENSION *sk_x509_extension_value(STACK_OF(X509_EXTENSION) *stack, int i) { | ||
362 | + return sk_X509_EXTENSION_value(stack, i); | ||
363 | } | ||
364 | |||
365 | /* X509_STORE_CTX_get_app_data is a macro. */ | ||
366 | @@ -590,7 +614,7 @@ | ||
367 | #define I2DTYPE int (*)() | ||
368 | #endif | ||
369 | |||
370 | -STACK * | ||
371 | +STACK_OF(X509) * | ||
372 | make_stack_from_der_sequence(PyObject * pyEncodedString){ | ||
373 | STACK_OF(X509) *certs; | ||
374 | Py_ssize_t encoded_string_len; | ||
375 | @@ -606,7 +630,7 @@ | ||
376 | return NULL; | ||
377 | } | ||
378 | |||
379 | - certs = ASN1_seq_unpack((unsigned char *)encoded_string, encoded_string_len, (D2ITYPE)d2i_X509, (void(*)())X509_free ); | ||
380 | + certs = ASN1_seq_unpack_X509((unsigned char *)encoded_string, encoded_string_len, d2i_X509, X509_free ); | ||
381 | if (!certs) { | ||
382 | PyErr_SetString(_x509_err, ERR_reason_error_string(ERR_get_error())); | ||
383 | return NULL; | ||
384 | @@ -616,13 +640,13 @@ | ||
385 | } | ||
386 | |||
387 | PyObject * | ||
388 | -get_der_encoding_stack(STACK * stack){ | ||
389 | +get_der_encoding_stack(STACK_OF(X509) *stack){ | ||
390 | PyObject * encodedString; | ||
391 | |||
392 | unsigned char * encoding; | ||
393 | int len; | ||
394 | |||
395 | - encoding = ASN1_seq_pack((STACK_OF(X509)*) stack, (I2DTYPE)i2d_X509, NULL, &len); | ||
396 | + encoding = ASN1_seq_pack_X509(stack, i2d_X509, NULL, &len); | ||
397 | if (!encoding) { | ||
398 | PyErr_SetString(_x509_err, ERR_reason_error_string(ERR_get_error())); | ||
399 | return NULL; | ||
400 | Index: SWIG/_aes.i | ||
401 | =================================================================== | ||
402 | --- SWIG/_aes.i (revision 695) | ||
403 | +++ SWIG/_aes.i (working copy) | ||
404 | @@ -76,7 +76,7 @@ | ||
405 | AES_encrypt((const unsigned char *)in, out, key); | ||
406 | else | ||
407 | AES_decrypt((const unsigned char *)in, out, key); | ||
408 | - return PyString_FromStringAndSize(out, outlen); | ||
409 | + return PyString_FromStringAndSize((char*)out, outlen); | ||
410 | } | ||
411 | |||
412 | int AES_type_check(AES_KEY *key) { | ||
413 | Index: SWIG/_util.i | ||
414 | =================================================================== | ||
415 | --- SWIG/_util.i (revision 695) | ||
416 | +++ SWIG/_util.i (working copy) | ||
417 | @@ -48,7 +48,7 @@ | ||
418 | PyErr_SetString(_util_err, ERR_reason_error_string(ERR_get_error())); | ||
419 | return NULL; | ||
420 | } | ||
421 | - obj = PyString_FromStringAndSize(ret, len); | ||
422 | + obj = PyString_FromStringAndSize((char*)ret, len); | ||
423 | OPENSSL_free(ret); | ||
424 | return obj; | ||
425 | } | ||
426 | Index: SWIG/_m2crypto.i | ||
427 | =================================================================== | ||
428 | --- SWIG/_m2crypto.i (revision 695) | ||
429 | +++ SWIG/_m2crypto.i (working copy) | ||
430 | @@ -38,6 +38,19 @@ | ||
431 | #define CONST098 | ||
432 | #endif | ||
433 | |||
434 | +/* Bring in STACK_OF macro definition */ | ||
435 | +%include <openssl/safestack.h> | ||
436 | + | ||
437 | +/* Bring in LHASH_OF macro definition */ | ||
438 | +/* XXX Can't include lhash.h where LHASH_OF is defined, because it includes | ||
439 | + XXX stdio.h etc. which we fail to include. So we have to (re)define | ||
440 | + XXX LHASH_OF here instead. | ||
441 | +%include <openssl/lhash.h> | ||
442 | +*/ | ||
443 | +#if OPENSSL_VERSION_NUMBER >= 0x10000000L | ||
444 | +#define LHASH_OF(type) struct lhash_st_##type | ||
445 | +#endif | ||
446 | + | ||
447 | %include constraints.i | ||
448 | %include _threads.i | ||
449 | %include _lib.i | ||
450 | Index: SWIG/_rand.i | ||
451 | =================================================================== | ||
452 | --- SWIG/_rand.i (revision 695) | ||
453 | +++ SWIG/_rand.i (working copy) | ||
454 | @@ -87,7 +87,7 @@ | ||
455 | Py_INCREF(Py_None); | ||
456 | return Py_None; | ||
457 | } else { | ||
458 | - PyTuple_SET_ITEM(tuple, 0, PyString_FromStringAndSize(blob, n)); | ||
459 | + PyTuple_SET_ITEM(tuple, 0, PyString_FromStringAndSize((char*)blob, n)); | ||
460 | PyMem_Free(blob); | ||
461 | PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong((long)ret)); | ||
462 | return tuple; | ||
463 | Index: SWIG/_pkcs7.i | ||
464 | =================================================================== | ||
465 | --- SWIG/_pkcs7.i (revision 695) | ||
466 | +++ SWIG/_pkcs7.i (working copy) | ||
467 | @@ -12,7 +12,7 @@ | ||
468 | %apply Pointer NONNULL { EVP_CIPHER * }; | ||
469 | %apply Pointer NONNULL { EVP_PKEY * }; | ||
470 | %apply Pointer NONNULL { PKCS7 * }; | ||
471 | -%apply Pointer NONNULL { STACK * }; | ||
472 | +%apply Pointer NONNULL { STACK_OF(X509) * }; | ||
473 | %apply Pointer NONNULL { X509 * }; | ||
474 | |||
475 | %rename(pkcs7_new) PKCS7_new; | ||
476 | @@ -54,8 +54,8 @@ | ||
477 | |||
478 | %threadallow pkcs7_encrypt; | ||
479 | %inline %{ | ||
480 | -PKCS7 *pkcs7_encrypt(STACK *stack, BIO *bio, EVP_CIPHER *cipher, int flags) { | ||
481 | - return PKCS7_encrypt((STACK_OF(X509) *)stack, bio, cipher, flags); | ||
482 | +PKCS7 *pkcs7_encrypt(STACK_OF(X509) *stack, BIO *bio, EVP_CIPHER *cipher, int flags) { | ||
483 | + return PKCS7_encrypt(stack, bio, cipher, flags); | ||
484 | } | ||
485 | |||
486 | PyObject *pkcs7_decrypt(PKCS7 *pkcs7, EVP_PKEY *pkey, X509 *cert, int flags) { | ||
487 | @@ -96,14 +96,14 @@ | ||
488 | |||
489 | %threadallow pkcs7_sign1; | ||
490 | %inline %{ | ||
491 | -PKCS7 *pkcs7_sign1(X509 *x509, EVP_PKEY *pkey, STACK *stack, BIO *bio, int flags) { | ||
492 | - return PKCS7_sign(x509, pkey, (STACK_OF(X509) *)stack, bio, flags); | ||
493 | +PKCS7 *pkcs7_sign1(X509 *x509, EVP_PKEY *pkey, STACK_OF(X509) *stack, BIO *bio, int flags) { | ||
494 | + return PKCS7_sign(x509, pkey, stack, bio, flags); | ||
495 | } | ||
496 | %} | ||
497 | |||
498 | %threadallow pkcs7_verify1; | ||
499 | %inline %{ | ||
500 | -PyObject *pkcs7_verify1(PKCS7 *pkcs7, STACK *stack, X509_STORE *store, BIO *data, int flags) { | ||
501 | +PyObject *pkcs7_verify1(PKCS7 *pkcs7, STACK_OF(X509) *stack, X509_STORE *store, BIO *data, int flags) { | ||
502 | int outlen; | ||
503 | char *outbuf; | ||
504 | BIO *bio; | ||
505 | @@ -113,7 +113,7 @@ | ||
506 | PyErr_SetString(PyExc_MemoryError, "pkcs7_verify1"); | ||
507 | return NULL; | ||
508 | } | ||
509 | - if (!PKCS7_verify(pkcs7, (STACK_OF(X509) *)stack, store, data, bio, flags)) { | ||
510 | + if (!PKCS7_verify(pkcs7, stack, store, data, bio, flags)) { | ||
511 | PyErr_SetString(_pkcs7_err, ERR_reason_error_string(ERR_get_error())); | ||
512 | BIO_free(bio); | ||
513 | return NULL; | ||
514 | @@ -131,7 +131,7 @@ | ||
515 | return ret; | ||
516 | } | ||
517 | |||
518 | -PyObject *pkcs7_verify0(PKCS7 *pkcs7, STACK *stack, X509_STORE *store, int flags) { | ||
519 | +PyObject *pkcs7_verify0(PKCS7 *pkcs7, STACK_OF(X509) *stack, X509_STORE *store, int flags) { | ||
520 | return pkcs7_verify1(pkcs7, stack, store, NULL, flags); | ||
521 | } | ||
522 | %} | ||
523 | @@ -229,7 +229,7 @@ | ||
524 | } | ||
525 | |||
526 | /* return STACK_OF(X509)* */ | ||
527 | -STACK *pkcs7_get0_signers(PKCS7 *p7, STACK *certs, int flags) { | ||
528 | +STACK_OF(X509) *pkcs7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags) { | ||
529 | return PKCS7_get0_signers(p7, certs, flags); | ||
530 | } | ||
531 |