Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/m2crypto/patches/m2crypto-0.22.5-no-sslv2.patch

    Annotation of /trunk/m2crypto/patches/m2crypto-0.22.5-no-sslv2.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 2770 - (hide annotations) (download)
    Fri Mar 4 10:13:47 2016 UTC (8 years, 2 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