diff options
7 files changed, 2008 insertions, 5 deletions
diff --git a/dev-python/m2crypto/ChangeLog b/dev-python/m2crypto/ChangeLog index c608a78baa2e..deebe2d83f8c 100644 --- a/dev-python/m2crypto/ChangeLog +++ b/dev-python/m2crypto/ChangeLog @@ -1,6 +1,15 @@ # ChangeLog for dev-python/m2crypto # Copyright 1999-2015 Gentoo Foundation; Distributed under the GPL v2 -# $Header: /var/cvsroot/gentoo-x86/dev-python/m2crypto/ChangeLog,v 1.86 2015/05/25 16:41:54 floppym Exp $ +# $Header: /var/cvsroot/gentoo-x86/dev-python/m2crypto/ChangeLog,v 1.87 2015/05/25 17:16:54 floppym Exp $ + +*m2crypto-0.21.1-r3 (25 May 2015) + + 25 May 2015; Mike Gilbert <floppym@gentoo.org> + +files/0.21.1-0001-Fixed-invalid-variable-name.patch, + +files/0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch, + +files/0.21.1-0003-Use-swig-generated-python-loader.patch, + +files/0.21.1-packaging.patch, +m2crypto-0.21.1-r3.ebuild: + Resolve issues with swig-3.0.5 in the older 0.21 fork as well. *m2crypto-0.22.3-r4 (25 May 2015) diff --git a/dev-python/m2crypto/Manifest b/dev-python/m2crypto/Manifest index 7b702b7d1597..69be9ac7421c 100644 --- a/dev-python/m2crypto/Manifest +++ b/dev-python/m2crypto/Manifest @@ -1,6 +1,10 @@ -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 +AUX 0.21.1-0001-Fixed-invalid-variable-name.patch 859 SHA256 7151956161ecb34d22128f4bcc47e3f4b1970926f2a4268db4bd8da02a7212dd SHA512 619ce5adacf90400f5e58b2271a5b85cc8da4005c17046f65075e74d051d91a672d1ee8a72587bca381b6e332b861170fa7851f2d4b7e2ff58d2858d21ceba3f WHIRLPOOL 09b29f5a5ef10a60d4397aedd32c05f04721a2994b55a7f0d8deae03558e70ee011f989cb7b832559cac603be79e3c9e9e74690f64cad0964e72745dd3875cf8 +AUX 0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch 52873 SHA256 e43711a4e82dbf3089b615bfca15893a2302da07686e974b3a5b0d7518f90af5 SHA512 3afba4795c2c007a42977cb1b567f793822581aa75563e6d63253986ad88730a0efa30b40e9a9858e7f40d97978a22ee11bf96e8daab778baf5ecfe717ca01aa WHIRLPOOL 52f1b84ad833edce969ed859b68e47614c166fb23439180fed3c6abedc54c81a967b054c4d54834bbe2679a51a9a45dd43f980c28a6cf67a7b08bca4a395cc86 +AUX 0.21.1-0003-Use-swig-generated-python-loader.patch 5514 SHA256 0e51b9d6ee1395927050da207fb461cb82c25a2d4bb2660fa1cfabafbf649aa4 SHA512 9e1714bb15ad084de130626ac9846f541824d1f64556dc880d02e70c828ea31dcb4eb0140fa11d185701a3b882d9a95a1b4cf0c1887c9c04ba5902860390e5c6 WHIRLPOOL f04cd99a345ed73f422e9023233141386c985678dbd64b17066bb1742c6e2bdf0cacec63369bf22b448fab1c50725a8365d7c8428daedf9be810988b6813bd35 +AUX 0.21.1-packaging.patch 2319 SHA256 8f874cc3a87b25fc13f1ab22ece4240b7f136887050d2ab7e3c5f2adcac94bed SHA512 fdbe229cc36216c8724b1d0f45a86708af433d066a024044dfd99047f9b161532f2ab32e88aac507bbf0b7873cda417894870852c2d678d30fa284667d28828e WHIRLPOOL fbf8bd6eb2d12869cd98d7bae7ce22f367adc6c46c4eec5cbcee4d9f5b268daf647f08e9f43b4840949a704c3c73a85c98f85c48ca9757b4b5df4fd7f5bca26a AUX 0.22.3-Use-swig-generated-python-loader.patch 4468 SHA256 e7e99614688bbf4ba2c596bf67bbdaefc479b36cf2375acd23380e652813bc75 SHA512 e194f67da2486d13dc0b68df993c7339e1818f773a907cb516102f3e8a1682fca24b8d2e22f1438443c7b95bf8e9d0fb52d63a74fb505c6d6b1e0e78afa798a4 WHIRLPOOL c441e785fcb2f049e2810eb5f5b1bfd4cfb2686dea8065459da2b3f2c2a66a4e7570a6e539dcf086d7bc1a5e2f54b34e348e39be6643e7cbfb1c6b854c555b51 AUX 0.22.3-packaging.patch 2572 SHA256 5631493d85e236a6ccc8e26f31cd034edd0fd0832049f4d7aa233bc588dd990a SHA512 ddb80f45de23441e4aba04ad0cf48dc9eab46b0d5031f22e7513424dcdd0f38340c04b1da7d17446c7eea2765249f4f7d00e67e0f8d2a3fb37e10aab6aa1d8e2 WHIRLPOOL fcc9133f9d3970643dea1b27b503036eb6a09ff23d66575913a25106c92b34a353b10e6bf27952e97c83cbf0c0352ce76071a96626a10879e77b3eef71e861f6 AUX m2crypto-0.21.1-cross-compile.patch 1437 SHA256 a63ace788d51b9b04847b6d50d83360648322edba773a0d0f375f7fa86d15cd0 SHA512 9c10f1638eb6aa891434b94d9a7d574d498ccfd4e2dc1de03692130b8700bb7c38123d07e6635755a4a9766231c9de4a17f822f44623bcdb8601f9b5f38d6cab WHIRLPOOL 1bc566f065d6809df0181bf610c8f20da59037038ea2470ffb6aa10b720ca6c5ceb0c9890f63024958d5eaf23a8b52d0556aa6a98be86a5cbaad0ec1a44163c0 @@ -8,14 +12,15 @@ AUX m2crypto-0.22.3-cross-compile.patch 1728 SHA256 87c2046e453f1dea08e03459a946 DIST M2Crypto-0.21.1.tar.gz 413563 SHA256 25b94498505c2d800ee465db0cc1aff097b1615adc3ac042a1c85ceca264fc0a SHA512 b261eed84b3bda8a664c065241c2007f6443235a0fbcdd856c5a0b1f015e75662724b72a56e94aeb174414fff5c8dd71dfcb4b18f677f576ab7e30811a8adf9b WHIRLPOOL 88f184452a660cff934371d18e0065974dec3cea052cf78ef0bbecf35ed2ef6d69f8a40016f1b3fbac24fa06697b7e4c5e9e1f6afd20d30ff63fa1c22b69e8d0 DIST M2Crypto-0.22.3.tar.gz 74795 SHA256 6071bfc817d94723e9b458a010d565365104f84aa73f7fe11919871f7562ff72 SHA512 c179d3cf03ced77aed24285ca3f1527d5e05bbfe091a1522bff94a940fd390213fbb9b83d7ccd43ceae49626b427ae8790782cf93ead85be1e063bc4121c62e0 WHIRLPOOL 66a9a6e7c9b195814048a1bcecf6ef71a269bebb9dbda73801c88b3ba27330b555a46d05c53bbd0778f9c1e1bb5f9c6e7e860de443bf16baffc2072ee5996e31 EBUILD m2crypto-0.21.1-r2.ebuild 1836 SHA256 5825d819a47f76f87a57670d3d540dd1dc55a6e58c045c649d9c0d43f1101805 SHA512 d7eead603d859425eb56dc687d7125c7008cbbc7cdfcb537ed17ec84b293bfb81be8298394920a97854982bc94747488277aa9e01de25e4f07cf904c724e081c WHIRLPOOL 4b442a936f0447a929f32579c0a6ec8a7021a895143eda48c3785fb1af5175d9c25378394f6f17e586bc8d01b6b66bc9ba2cc78541e8c47b1c9a1ed94225c836 +EBUILD m2crypto-0.21.1-r3.ebuild 1398 SHA256 fc891448b4de54ec5ac8ae76e7e9890105986256bcb6e15123d9a8dbb30ff5de SHA512 62cb441d212f0b6fbc9e51fd92fec518cd26abd705eae61d28db3f0fe06bc751130aaa2b37a5cdf5ee678f9d3f0158499b396ca3f253e6ad48ad5204bb5eeacb WHIRLPOOL 431f955f0d7dade8a51a2553cffab1d0eb9c35b09dbd4f4201066983c53b611227556a3a431e276219eda5c2b6a1208f12c2a4b24c1ada5e5f14583a4650371b EBUILD m2crypto-0.22.3-r3.ebuild 1476 SHA256 93114f60c723983f4a2d4cebaf429218c8aef4048426923b735f6b8d537b09a2 SHA512 6fdac59e390a5f622d530e834271a81b4e026b20b3404c652d59c99ff2c890d7f4cfc11b960dcd0e4ac3f7b89c8e290ac12901acb8eba8f090d5da13ead8a78c WHIRLPOOL c1ed113f3c3ad44e53e9423fb45e7887351ce2577e1c992b4cc174b29d02d4153f9b86c2f174b8399a3b4f8f1a5323967247b0e408a66d955a2344b3b4063929 EBUILD m2crypto-0.22.3-r4.ebuild 1263 SHA256 11e715a716ea0e30f0da4aaffc72c39c5f0bb7bcbfa474229256b06b805ce72b SHA512 150d31cdd98759905259869725cc98a2f932f7e782b95a05e70c4a777fa44c7f13fa6f6bcdae4b8abd6eb045b6d074aef2adb20806d0404c436fcb41be447df2 WHIRLPOOL 595595d9a3a18e8d65f538f8a4de65ef64b912af2d3f240812330953fe961124ef305450173260ad7f52cd1a85a3991306035b0998ba57eb9d60618d04357c9a -MISC ChangeLog 12000 SHA256 bef836dfc52d18387eb167219fd9a2b53bd50ec29732f18b81af2fbae4e1814f SHA512 848de2b17608498a8c9836543523e081541e9b58a5169dee6098916a3d4755382e2440cc8fcf23df188417286add64c256deafe8d32591405e29d074b8d88732 WHIRLPOOL d3278857a84b14235bdb1b5d87dafe2d7799cf87b73680ce2924e227e5fe38408bb0599874516897d855aab12ee3af80d38032e29b0d28ba3c4c0b40bf76e6be +MISC ChangeLog 12396 SHA256 8b47ea8f95065f42c4284169130628ab07484bbb94ee19191dcbd93b2c5ddabc SHA512 7c8595002c3e4f691a440396c6712172df6af8a853700501a5acb09b1ffeea2e19eab1992a34dafb7efdc4170ec95bd6cf5af43cc21c9705f0a102992089deb0 WHIRLPOOL 6888a3bca42c9278298e58cfe260b77a82f046830f58d0d2b4f876eb76f06774b7b430852f737397270e41786c15084189c743b6ef38984d1bb64ba9ca74fec0 MISC metadata.xml 231 SHA256 4b3c3ef12b8947ff65c09c0c6bbeda5e9837776cbd593d20951d4fca97b38fc8 SHA512 70d64f2f5642ac485ed4b1ab58e307485d3bbe417edaab9c0cfc6ca1ad56de0b26b350b439bff4ac3d8d4c432df4b086f24f715a1ce631b8231bcd5cb9938561 WHIRLPOOL 59674c4927ea7a1df761e8ff83a04cafa8fc07973491a2c2e033e5afc2dead61366f0f66c8b14290b9e0652af24a8a0919753f8020e8a510ce1bbe4395165ae2 -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 -iF4EAREIAAYFAlVjUNQACgkQC77qH+pIQ6SFqgD/fT2AOxVyCJg6nyz4iM6Ry5RQ -iO5exXF9IbQ4zvBGVaIBAKf1Wr4pIGhOKXUrg6VIA96c6g/P1RScgiXDpNR3PDkg -=HAdF +iF4EAREIAAYFAlVjWQcACgkQC77qH+pIQ6S5FQEAkOQfPym0iWR5Uxj7FZwbULRD +EXg0otSK23cApspLnO4BAMPiVkV/K9Z+23hZhpJez/zVI/pXt04rINxDfzDCmQzF +=Y54s -----END PGP SIGNATURE----- diff --git a/dev-python/m2crypto/files/0.21.1-0001-Fixed-invalid-variable-name.patch b/dev-python/m2crypto/files/0.21.1-0001-Fixed-invalid-variable-name.patch new file mode 100644 index 000000000000..a055d39fe053 --- /dev/null +++ b/dev-python/m2crypto/files/0.21.1-0001-Fixed-invalid-variable-name.patch @@ -0,0 +1,25 @@ +From 3afe5a15df02bce629051e67a691f2b21ce3cfa7 Mon Sep 17 00:00:00 2001 +From: Hugo Castilho <hugo.p.castilho@telecom.pt> +Date: Fri, 2 May 2014 15:50:08 +0100 +Subject: [PATCH 1/3] Fixed invalid variable name + +--- + M2Crypto/ASN1.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/M2Crypto/ASN1.py b/M2Crypto/ASN1.py +index 09d9e9f..bb306ef 100644 +--- a/M2Crypto/ASN1.py ++++ b/M2Crypto/ASN1.py +@@ -174,7 +174,7 @@ class ASN1_UTCTIME: + raise ValueError("Invalid date: %s" % date) + month, rest = date.split(' ', 1) + if month not in self._ssl_months: +- raise ValueError("Invalid date %s: Invalid month: %s" % (date, m)) ++ raise ValueError("Invalid date %s: Invalid month: %s" % (date, month)) + if rest.endswith(' GMT'): + timezone = UTC + rest = rest[:-4] +-- +2.4.1 + diff --git a/dev-python/m2crypto/files/0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch b/dev-python/m2crypto/files/0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch new file mode 100644 index 000000000000..52dd74af4bed --- /dev/null +++ b/dev-python/m2crypto/files/0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch @@ -0,0 +1,1697 @@ +From 452d50d64a8e3368fe93db561a14a7bd14ca1b3c Mon Sep 17 00:00:00 2001 +From: Andreas Moser <amoser@google.com> +Date: Thu, 9 Oct 2014 15:13:12 +0200 +Subject: [PATCH 2/3] Fixing memory leaks in the SWIG wrapper. + +--- + SWIG/_aes.i | 26 +++++----- + SWIG/_bio.i | 28 ++++++----- + SWIG/_dh.i | 36 ++++++++------ + SWIG/_dsa.i | 106 ++++++++++++++++++++++++++--------------- + SWIG/_ec.i | 94 +++++++++++++++++++++++-------------- + SWIG/_evp.i | 151 ++++++++++++++++++++++++++++++++++------------------------- + SWIG/_lib.i | 124 ++++++++++++++++++++++++++++++++++-------------- + SWIG/_rand.i | 16 +++---- + SWIG/_rc4.i | 21 +++++---- + SWIG/_rsa.i | 125 +++++++++++++++++++++++++++++-------------------- + SWIG/_ssl.i | 51 ++++++++++---------- + SWIG/_util.i | 24 +++++----- + 12 files changed, 485 insertions(+), 317 deletions(-) + +diff --git a/SWIG/_aes.i b/SWIG/_aes.i +index 013531b..31e9252 100644 +--- a/SWIG/_aes.i ++++ b/SWIG/_aes.i +@@ -42,16 +42,16 @@ void AES_free(AES_KEY *key) { + // otherwise: encrypt (Python code will supply the value 1.) + */ + PyObject *AES_set_key(AES_KEY *key, PyObject *value, int bits, int op) { +- const void *vbuf; +- Py_ssize_t vlen; ++ Py_buffer vbuf; + +- if (PyObject_AsReadBuffer(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + + if (op == 0) +- AES_set_encrypt_key(vbuf, bits, key); ++ AES_set_encrypt_key(vbuf.buf, bits, key); + else +- AES_set_decrypt_key(vbuf, bits, key); ++ AES_set_decrypt_key(vbuf.buf, bits, key); ++ m2_PyBuffer_Release(value, &vbuf); + Py_INCREF(Py_None); + return Py_None; + } +@@ -61,21 +61,23 @@ PyObject *AES_set_key(AES_KEY *key, PyObject *value, int bits, int op) { + // otherwise: encrypt (Python code will supply the value 1.) + */ + PyObject *AES_crypt(const AES_KEY *key, PyObject *in, int outlen, int op) { +- const void *buf; +- Py_ssize_t len; + unsigned char *out; ++ Py_buffer buf; + +- if (PyObject_AsReadBuffer(in, &buf, &len) == -1) +- return NULL; ++ if (m2_PyObject_GetBuffer(in, &buf, PyBUF_SIMPLE) == -1) ++ return NULL; + + if (!(out=(unsigned char *)PyMem_Malloc(outlen))) { + PyErr_SetString(PyExc_MemoryError, "AES_crypt"); ++ m2_PyBuffer_Release(in, &buf); + return NULL; + } ++ + if (op == 0) +- AES_encrypt((const unsigned char *)in, out, key); ++ AES_encrypt((const unsigned char *)buf.buf, out, key); + else +- AES_decrypt((const unsigned char *)in, out, key); ++ AES_decrypt((const unsigned char *)buf.buf, out, key); ++ m2_PyBuffer_Release(in, &buf); + return PyString_FromStringAndSize((char*)out, outlen); + } + +diff --git a/SWIG/_bio.i b/SWIG/_bio.i +index bae3453..115b694 100644 +--- a/SWIG/_bio.i ++++ b/SWIG/_bio.i +@@ -121,20 +121,21 @@ PyObject *bio_gets(BIO *bio, int num) { + } + + int bio_write(BIO *bio, PyObject *from) { +- const void *fbuf; +- int flen, ret; ++ Py_buffer fbuf; ++ int ret; + +- if (m2_PyObject_AsReadBufferInt(from, &fbuf, &flen) == -1) +- return -1; ++ if (m2_PyObject_GetBufferInt(from, &fbuf, PyBUF_SIMPLE) == -1) ++ return -1; + + Py_BEGIN_ALLOW_THREADS +- ret = BIO_write(bio, fbuf, flen); ++ ret = BIO_write(bio, fbuf.buf, fbuf.len); + Py_END_ALLOW_THREADS + if (ret < 0) { + if (ERR_peek_error()) { + PyErr_SetString(_bio_err, ERR_reason_error_string(ERR_get_error())); + } + } ++ m2_PyBuffer_Release(from, &fbuf); + return ret; + } + +@@ -175,15 +176,20 @@ int bio_get_flags(BIO *bio) { + } + + PyObject *bio_set_cipher(BIO *b, EVP_CIPHER *c, PyObject *key, PyObject *iv, int op) { +- const void *kbuf, *ibuf; +- Py_ssize_t klen, ilen; ++ Py_buffer kbuf, ibuf; + +- if ((PyObject_AsReadBuffer(key, &kbuf, &klen) == -1) +- || (PyObject_AsReadBuffer(iv, &ibuf, &ilen) == -1)) +- return NULL; ++ if (m2_PyObject_GetBuffer(key, &kbuf, PyBUF_SIMPLE) == -1) ++ return NULL; ++ ++ if (m2_PyObject_GetBuffer(iv, &ibuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(key, &kbuf); ++ return NULL; ++ } + + BIO_set_cipher(b, (const EVP_CIPHER *)c, +- (unsigned char *)kbuf, (unsigned char *)ibuf, op); ++ (unsigned char *)kbuf.buf, (unsigned char *)ibuf.buf, op); ++ m2_PyBuffer_Release(iv, &ibuf); ++ m2_PyBuffer_Release(key, &kbuf); + Py_INCREF(Py_None); + return Py_None; + } +diff --git a/SWIG/_dh.i b/SWIG/_dh.i +index 6083d4e..b95671c 100644 +--- a/SWIG/_dh.i ++++ b/SWIG/_dh.i +@@ -83,33 +83,37 @@ int dh_check(DH *dh) { + } + + PyObject *dh_compute_key(DH *dh, PyObject *pubkey) { +- const void *pkbuf; +- int pklen, klen; ++ Py_buffer pkbuf; ++ int klen; + void *key; + BIGNUM *pk; + PyObject *ret; + +- if (m2_PyObject_AsReadBufferInt(pubkey, &pkbuf, &pklen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(pubkey, &pkbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(pk = BN_mpi2bn((unsigned char *)pkbuf, pklen, NULL))) { ++ if (!(pk = BN_mpi2bn((unsigned char *)pkbuf.buf, pkbuf.len, NULL))) { + PyErr_SetString(_dh_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(pubkey, &pkbuf); + return NULL; + } + if (!(key = PyMem_Malloc(DH_size(dh)))) { + BN_free(pk); + PyErr_SetString(PyExc_MemoryError, "dh_compute_key"); ++ m2_PyBuffer_Release(pubkey, &pkbuf); + return NULL; + } + if ((klen = DH_compute_key((unsigned char *)key, pk, dh)) == -1) { + BN_free(pk); + PyMem_Free(key); + PyErr_SetString(_dh_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(pubkey, &pkbuf); + return NULL; + } + ret = PyString_FromStringAndSize((const char *)key, klen); + BN_free(pk); + PyMem_Free(key); ++ m2_PyBuffer_Release(pubkey, &pkbuf); + return ret; + } + +@@ -147,39 +151,41 @@ PyObject *dh_get_priv(DH *dh) { + + PyObject *dh_set_p(DH *dh, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_mpi2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_mpi2bn((unsigned char *)vbuf.buf, vbuf.len, NULL))) { + PyErr_SetString(_dh_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + if (dh->p) + BN_free(dh->p); + dh->p = bn; ++ m2_PyBuffer_Release(value, &vbuf); + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *dh_set_g(DH *dh, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_mpi2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_mpi2bn((unsigned char *)vbuf.buf, vbuf.len, NULL))) { + PyErr_SetString(_dh_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + if (dh->g) + BN_free(dh->g); + dh->g = bn; + Py_INCREF(Py_None); ++ m2_PyBuffer_Release(value, &vbuf); + return Py_None; + } + %} +diff --git a/SWIG/_dsa.i b/SWIG/_dsa.i +index a35dd88..e5d466b 100644 +--- a/SWIG/_dsa.i ++++ b/SWIG/_dsa.i +@@ -99,57 +99,60 @@ PyObject *dsa_get_priv(DSA *dsa) { + + PyObject *dsa_set_p(DSA *dsa, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_mpi2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_mpi2bn((unsigned char *)vbuf.buf, vbuf.len, NULL))) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + if (dsa->p) + BN_free(dsa->p); + dsa->p = bn; ++ m2_PyBuffer_Release(value, &vbuf); + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *dsa_set_q(DSA *dsa, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_mpi2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_mpi2bn((unsigned char *)vbuf.buf, vbuf.len, NULL))) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + if (dsa->q) + BN_free(dsa->q); + dsa->q = bn; ++ m2_PyBuffer_Release(value, &vbuf); + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *dsa_set_g(DSA *dsa, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) + return NULL; + +- if (!(bn = BN_mpi2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_mpi2bn((unsigned char *)vbuf.buf, vbuf.len, NULL))) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + if (dsa->g) + BN_free(dsa->g); + dsa->g = bn; ++ m2_PyBuffer_Release(value, &vbuf); + Py_INCREF(Py_None); + return Py_None; + } +@@ -236,97 +239,124 @@ DSA *dsa_read_pub_key(BIO *f, PyObject *pyfunc) { + } + + PyObject *dsa_sign(DSA *dsa, PyObject *value) { +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + PyObject *tuple; + DSA_SIG *sig; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) + return NULL; + +- if (!(sig = DSA_do_sign(vbuf, vlen, dsa))) { ++ if (!(sig = DSA_do_sign(vbuf.buf, vbuf.len, dsa))) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + if (!(tuple = PyTuple_New(2))) { + DSA_SIG_free(sig); + PyErr_SetString(PyExc_RuntimeError, "PyTuple_New() fails"); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + PyTuple_SET_ITEM(tuple, 0, dsa_sig_get_r(sig)); + PyTuple_SET_ITEM(tuple, 1, dsa_sig_get_s(sig)); + DSA_SIG_free(sig); ++ m2_PyBuffer_Release(value, &vbuf); + return tuple; + } + + int dsa_verify(DSA *dsa, PyObject *value, PyObject *r, PyObject *s) { +- const void *vbuf, *rbuf, *sbuf; +- int vlen, rlen, slen; ++ Py_buffer vbuf, rbuf, sbuf; + DSA_SIG *sig; + int ret; + +- if ((m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- || (m2_PyObject_AsReadBufferInt(r, &rbuf, &rlen) == -1) +- || (m2_PyObject_AsReadBufferInt(s, &sbuf, &slen) == -1)) ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return -1; ++ if (m2_PyObject_GetBufferInt(r, &rbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(value, &vbuf); ++ return -1; ++ } ++ if (m2_PyObject_GetBufferInt(s, &sbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); + return -1; ++ } + + if (!(sig = DSA_SIG_new())) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + return -1; + } +- if (!(sig->r = BN_mpi2bn((unsigned char *)rbuf, rlen, NULL))) { ++ if (!(sig->r = BN_mpi2bn((unsigned char *)rbuf.buf, rbuf.len, NULL))) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); + DSA_SIG_free(sig); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + return -1; + } +- if (!(sig->s = BN_mpi2bn((unsigned char *)sbuf, slen, NULL))) { ++ if (!(sig->s = BN_mpi2bn((unsigned char *)sbuf.buf, sbuf.len, NULL))) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); + DSA_SIG_free(sig); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + return -1; + } +- ret = DSA_do_verify(vbuf, vlen, sig, dsa); ++ ret = DSA_do_verify(vbuf.buf, vbuf.len, sig, dsa); + DSA_SIG_free(sig); + if (ret == -1) + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + return ret; + } + + PyObject *dsa_sign_asn1(DSA *dsa, PyObject *value) { +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + void *sigbuf; + unsigned int siglen; + PyObject *ret; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) + return NULL; + + if (!(sigbuf = PyMem_Malloc(DSA_size(dsa)))) { + PyErr_SetString(PyExc_MemoryError, "dsa_sign_asn1"); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } +- if (!DSA_sign(0, vbuf, vlen, (unsigned char *)sigbuf, &siglen, dsa)) { ++ if (!DSA_sign(0, vbuf.buf, vbuf.len, ++ (unsigned char *)sigbuf, &siglen, dsa)) { + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); + PyMem_Free(sigbuf); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + ret = PyString_FromStringAndSize(sigbuf, siglen); + PyMem_Free(sigbuf); ++ m2_PyBuffer_Release(value, &vbuf); + return ret; + } + + int dsa_verify_asn1(DSA *dsa, PyObject *value, PyObject *sig) { +- const void *vbuf; +- void *sbuf; +- int vlen, slen, ret; ++ int ret; ++ Py_buffer vbuf, sbuf; + +- if ((m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- || (m2_PyObject_AsReadBufferInt(sig, (const void **)&sbuf, &slen) +- == -1)) +- return -1; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return -1; ++ if (m2_PyObject_GetBufferInt(sig, &sbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(value, &vbuf); ++ return -1; ++ } + +- if ((ret = DSA_verify(0, vbuf, vlen, sbuf, slen, dsa)) == -1) ++ if ((ret = DSA_verify(0, (const void *) vbuf.buf, vbuf.len, ++ (void *) sbuf.buf, sbuf.len, dsa)) == -1) + PyErr_SetString(_dsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(sig, &sbuf); + return ret; + } + +diff --git a/SWIG/_ec.i b/SWIG/_ec.i +index f0e52bd..0271c73 100644 +--- a/SWIG/_ec.i ++++ b/SWIG/_ec.i +@@ -255,56 +255,76 @@ PyObject *ecdsa_sig_get_s(ECDSA_SIG *ecdsa_sig) { + } + + PyObject *ecdsa_sign(EC_KEY *key, PyObject *value) { +- const void *vbuf; +- int vlen; + PyObject *tuple; + ECDSA_SIG *sig; ++ Py_buffer vbuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(sig = ECDSA_do_sign(vbuf, vlen, key))) { ++ if (!(sig = ECDSA_do_sign(vbuf.buf, vbuf.len, key))) { + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + if (!(tuple = PyTuple_New(2))) { + ECDSA_SIG_free(sig); + PyErr_SetString(PyExc_RuntimeError, "PyTuple_New() fails"); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + PyTuple_SET_ITEM(tuple, 0, ecdsa_sig_get_r(sig)); + PyTuple_SET_ITEM(tuple, 1, ecdsa_sig_get_s(sig)); + ECDSA_SIG_free(sig); ++ m2_PyBuffer_Release(value, &vbuf); + return tuple; + } + + int ecdsa_verify(EC_KEY *key, PyObject *value, PyObject *r, PyObject *s) { +- const void *vbuf, *rbuf, *sbuf; +- int vlen, rlen, slen; ++ Py_buffer vbuf, rbuf, sbuf; + ECDSA_SIG *sig; + int ret; + +- if ((m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- || (m2_PyObject_AsReadBufferInt(r, &rbuf, &rlen) == -1) +- || (m2_PyObject_AsReadBufferInt(s, &sbuf, &slen) == -1)) +- return -1; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return -1; ++ if (m2_PyObject_GetBufferInt(r, &rbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(value, &vbuf); ++ return -1; ++ } ++ if (m2_PyObject_GetBufferInt(s, &sbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ return -1; ++ } + + if (!(sig = ECDSA_SIG_new())) { + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + return -1; + } +- if (!BN_mpi2bn((unsigned char *)rbuf, rlen, sig->r)) { ++ if (!BN_mpi2bn((unsigned char *)rbuf.buf, rbuf.len, sig->r)) { + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); + ECDSA_SIG_free(sig); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + return -1; + } +- if (!BN_mpi2bn((unsigned char *)sbuf, slen, sig->s)) { ++ if (!BN_mpi2bn((unsigned char *)sbuf.buf, sbuf.len, sig->s)) { + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); + ECDSA_SIG_free(sig); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + return -1; + } +- ret = ECDSA_do_verify(vbuf, vlen, sig, key); ++ ret = ECDSA_do_verify(vbuf.buf, vbuf.len, sig, key); + ECDSA_SIG_free(sig); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(r, &rbuf); ++ m2_PyBuffer_Release(s, &sbuf); + if (ret == -1) + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); + return ret; +@@ -312,42 +332,49 @@ int ecdsa_verify(EC_KEY *key, PyObject *value, PyObject *r, PyObject *s) { + + + PyObject *ecdsa_sign_asn1(EC_KEY *key, PyObject *value) { +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + void *sigbuf; + unsigned int siglen; + PyObject *ret; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) + return NULL; + + if (!(sigbuf = PyMem_Malloc(ECDSA_size(key)))) { + PyErr_SetString(PyExc_MemoryError, "ecdsa_sign_asn1"); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } +- if (!ECDSA_sign(0, vbuf, vlen, (unsigned char *)sigbuf, &siglen, key)) { ++ if (!ECDSA_sign(0, vbuf.buf, vbuf.len, ++ (unsigned char *)sigbuf, &siglen, key)) { + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); + PyMem_Free(sigbuf); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } + ret = PyString_FromStringAndSize(sigbuf, siglen); + PyMem_Free(sigbuf); ++ m2_PyBuffer_Release(value, &vbuf); + return ret; + } + + + int ecdsa_verify_asn1(EC_KEY *key, PyObject *value, PyObject *sig) { +- const void *vbuf; +- void *sbuf; +- int vlen, slen, ret; ++ Py_buffer vbuf, sbuf; ++ int ret; + +- if ((m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- || (m2_PyObject_AsReadBufferInt(sig, (const void **)&sbuf, &slen) +- == -1)) +- return -1; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return -1; ++ if (m2_PyObject_GetBufferInt(sig, &sbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(value, &vbuf); ++ return -1; ++ } + +- if ((ret = ECDSA_verify(0, vbuf, vlen, sbuf, slen, key)) == -1) ++ if ((ret = ECDSA_verify(0, (const void *) vbuf.buf, vbuf.len, ++ sbuf.buf, sbuf.len, key)) == -1) + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &vbuf); ++ m2_PyBuffer_Release(sig, &sbuf); + return ret; + } + +@@ -385,18 +412,17 @@ PyObject *ecdh_compute_key(EC_KEY *keypairA, EC_KEY *pubkeyB) { + + + EC_KEY* ec_key_from_pubkey_der(PyObject *pubkey) { +- const void *keypairbuf; +- Py_ssize_t keypairbuflen; ++ Py_buffer keypairbuf; + const unsigned char *tempBuf; + EC_KEY *keypair; + +- if (PyObject_AsReadBuffer(pubkey, &keypairbuf, &keypairbuflen) == -1) +- { +- return NULL; +- } ++ if (m2_PyObject_GetBufferInt(pubkey, &keypairbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- tempBuf = (const unsigned char *)keypairbuf; +- if ((keypair = d2i_EC_PUBKEY( NULL, &tempBuf, keypairbuflen)) == 0) ++ tempBuf = (const unsigned char *)keypairbuf.buf; ++ keypair = d2i_EC_PUBKEY( NULL, &tempBuf, keypairbuf.len); ++ m2_PyBuffer_Release(pubkey, &keypairbuf); ++ if (keypair == 0) + { + PyErr_SetString(_ec_err, ERR_reason_error_string(ERR_get_error())); + return NULL; +diff --git a/SWIG/_evp.i b/SWIG/_evp.i +index 0593eed..ff36521 100644 +--- a/SWIG/_evp.i ++++ b/SWIG/_evp.i +@@ -169,22 +169,23 @@ PyObject *pkcs5_pbkdf2_hmac_sha1(PyObject *pass, + int iter, + int keylen) { + unsigned char key[EVP_MAX_KEY_LENGTH]; +- unsigned char *saltbuf; +- char *passbuf; + PyObject *ret; +- int passlen, saltlen; ++ Py_buffer passbuf, saltbuf; + +- if (m2_PyObject_AsReadBufferInt(pass, (const void **)&passbuf, +- &passlen) == -1) +- return NULL; +- if (m2_PyObject_AsReadBufferInt(salt, (const void **)&saltbuf, +- &saltlen) == -1) ++ if (m2_PyObject_GetBufferInt(pass, &passbuf, PyBUF_SIMPLE) == -1) ++ return NULL; ++ if (m2_PyObject_GetBufferInt(salt, &saltbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(pass, &passbuf); + return NULL; ++ } + +- PKCS5_PBKDF2_HMAC_SHA1(passbuf, passlen, saltbuf, saltlen, iter, +- keylen, key); ++ PKCS5_PBKDF2_HMAC_SHA1((char *) passbuf.buf, passbuf.len, ++ (unsigned char *) saltbuf.buf, saltbuf.len, ++ iter, keylen, key); + ret = PyString_FromStringAndSize((char*)key, keylen); + OPENSSL_cleanse(key, keylen); ++ m2_PyBuffer_Release(pass, &passbuf); ++ m2_PyBuffer_Release(salt, &saltbuf); + return ret; + } + +@@ -202,13 +203,15 @@ void md_ctx_free(EVP_MD_CTX *ctx) { + } + + int digest_update(EVP_MD_CTX *ctx, PyObject *blob) { +- const void *buf; +- Py_ssize_t len; ++ Py_buffer buf; ++ int ret; + +- if (PyObject_AsReadBuffer(blob, &buf, &len) == -1) +- return -1; ++ if (m2_PyObject_GetBuffer(blob, &buf, PyBUF_SIMPLE) == -1) ++ return -1; + +- return EVP_DigestUpdate(ctx, buf, len); ++ ret = EVP_DigestUpdate(ctx, buf.buf, buf.len); ++ m2_PyBuffer_Release(blob, &buf); ++ return ret; + } + + PyObject *digest_final(EVP_MD_CTX *ctx) { +@@ -247,25 +250,25 @@ void hmac_ctx_free(HMAC_CTX *ctx) { + } + + PyObject *hmac_init(HMAC_CTX *ctx, PyObject *key, const EVP_MD *md) { +- const void *kbuf; +- int klen; ++ Py_buffer kbuf; + +- if (m2_PyObject_AsReadBufferInt(key, &kbuf, &klen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(key, &kbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- HMAC_Init(ctx, kbuf, klen, md); ++ HMAC_Init(ctx, kbuf.buf, kbuf.len, md); ++ m2_PyBuffer_Release(key, &kbuf); + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *hmac_update(HMAC_CTX *ctx, PyObject *blob) { +- const void *buf; +- Py_ssize_t len; ++ Py_buffer buf; + +- if (PyObject_AsReadBuffer(blob, &buf, &len) == -1) +- return NULL; ++ if (m2_PyObject_GetBuffer(blob, &buf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- HMAC_Update(ctx, buf, len); ++ HMAC_Update(ctx, buf.buf, buf.len); ++ m2_PyBuffer_Release(blob, &buf); + Py_INCREF(Py_None); + return Py_None; + } +@@ -286,25 +289,30 @@ PyObject *hmac_final(HMAC_CTX *ctx) { + } + + PyObject *hmac(PyObject *key, PyObject *data, const EVP_MD *md) { +- const void *kbuf, *dbuf; + void *blob; +- int klen; + unsigned int blen; +- Py_ssize_t dlen; + PyObject *ret; ++ Py_buffer kbuf, dbuf; + +- if ((m2_PyObject_AsReadBufferInt(key, &kbuf, &klen) == -1) +- || (PyObject_AsReadBuffer(data, &dbuf, &dlen) == -1)) ++ if (m2_PyObject_GetBufferInt(key, &kbuf, PyBUF_SIMPLE) == -1) + return NULL; ++ if (m2_PyObject_GetBuffer(data, &dbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(key, &kbuf); ++ return NULL; ++ } + + if (!(blob = PyMem_Malloc(EVP_MAX_MD_SIZE))) { + PyErr_SetString(PyExc_MemoryError, "hmac"); ++ m2_PyBuffer_Release(key, &kbuf); ++ m2_PyBuffer_Release(data, &dbuf); + return NULL; + } +- HMAC(md, kbuf, klen, dbuf, dlen, blob, &blen); ++ HMAC(md, kbuf.buf, kbuf.len, dbuf.buf, dbuf.len, blob, &blen); + blob = PyMem_Realloc(blob, blen); + ret = PyString_FromStringAndSize(blob, blen); + PyMem_Free(blob); ++ m2_PyBuffer_Release(key, &kbuf); ++ m2_PyBuffer_Release(data, &dbuf); + return ret; + } + +@@ -329,61 +337,74 @@ PyObject *bytes_to_key(const EVP_CIPHER *cipher, EVP_MD *md, + PyObject *iv, /* Not used */ + int iter) { + unsigned char key[EVP_MAX_KEY_LENGTH]; +- const void *dbuf, *sbuf; +- int dlen, klen; +- Py_ssize_t slen; ++ int klen; + PyObject *ret; ++ Py_buffer dbuf, sbuf; + +- if ((m2_PyObject_AsReadBufferInt(data, &dbuf, &dlen) == -1) +- || (PyObject_AsReadBuffer(salt, &sbuf, &slen) == -1)) ++ if (m2_PyObject_GetBufferInt(data, &dbuf, PyBUF_SIMPLE) == -1) + return NULL; ++ if (m2_PyObject_GetBuffer(salt, &sbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(data, &dbuf); ++ return NULL; ++ } + +- assert((slen == 8) || (slen == 0)); +- klen = EVP_BytesToKey(cipher, md, (unsigned char *)sbuf, +- (unsigned char *)dbuf, dlen, iter, ++ assert((sbuf.len == 8) || (sbuf.len == 0)); ++ klen = EVP_BytesToKey(cipher, md, (unsigned char *)sbuf.buf, ++ (unsigned char *)dbuf.buf, dbuf.len, iter, + key, NULL); /* Since we are not returning IV no need to derive it */ + ret = PyString_FromStringAndSize((char*)key, klen); ++ m2_PyBuffer_Release(data, &dbuf); ++ m2_PyBuffer_Release(salt, &sbuf); + return ret; + } + + PyObject *cipher_init(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, + PyObject *key, PyObject *iv, int mode) { +- const void *kbuf, *ibuf; +- Py_ssize_t klen, ilen; ++ Py_buffer kbuf, ibuf; + +- if ((PyObject_AsReadBuffer(key, &kbuf, &klen) == -1) +- || (PyObject_AsReadBuffer(iv, &ibuf, &ilen) == -1)) ++ if (m2_PyObject_GetBuffer(key, &kbuf, PyBUF_SIMPLE) == -1) ++ return NULL; ++ if (m2_PyObject_GetBuffer(iv, &ibuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(key, &kbuf); + return NULL; ++ } + +- if (!EVP_CipherInit(ctx, cipher, (unsigned char *)kbuf, +- (unsigned char *)ibuf, mode)) { ++ if (!EVP_CipherInit(ctx, cipher, (unsigned char *)kbuf.buf, ++ (unsigned char *)ibuf.buf, mode)) { + PyErr_SetString(_evp_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(key, &kbuf); ++ m2_PyBuffer_Release(iv, &ibuf); + return NULL; + } + Py_INCREF(Py_None); ++ m2_PyBuffer_Release(key, &kbuf); ++ m2_PyBuffer_Release(iv, &ibuf); + return Py_None; + } + + PyObject *cipher_update(EVP_CIPHER_CTX *ctx, PyObject *blob) { +- const void *buf; +- int len, olen; ++ int olen; + void *obuf; + PyObject *ret; ++ Py_buffer buf; + +- if (m2_PyObject_AsReadBufferInt(blob, &buf, &len) == -1) ++ if (m2_PyObject_GetBuffer(blob, &buf, PyBUF_SIMPLE) == -1) + return NULL; + +- if (!(obuf = PyMem_Malloc(len + EVP_CIPHER_CTX_block_size(ctx) - 1))) { ++ if (!(obuf = PyMem_Malloc(buf.len + EVP_CIPHER_CTX_block_size(ctx) - 1))) { + PyErr_SetString(PyExc_MemoryError, "cipher_update"); ++ m2_PyBuffer_Release(blob, &buf); + return NULL; + } +- if (!EVP_CipherUpdate(ctx, obuf, &olen, (unsigned char *)buf, len)) { ++ if (!EVP_CipherUpdate(ctx, obuf, &olen, (unsigned char *)buf.buf, buf.len)) { + PyMem_Free(obuf); + PyErr_SetString(_evp_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(blob, &buf); + return NULL; + } + ret = PyString_FromStringAndSize(obuf, olen); + PyMem_Free(obuf); ++ m2_PyBuffer_Release(blob, &buf); + return ret; + } + +@@ -407,17 +428,18 @@ PyObject *cipher_final(EVP_CIPHER_CTX *ctx) { + } + + PyObject *sign_update(EVP_MD_CTX *ctx, PyObject *blob) { +- const void *buf; +- Py_ssize_t len; ++ Py_buffer buf; + +- if (PyObject_AsReadBuffer(blob, &buf, &len) == -1) ++ if (m2_PyObject_GetBuffer(blob, &buf, PyBUF_SIMPLE) == -1) + return NULL; + +- if (!EVP_SignUpdate(ctx, buf, len)) { ++ if (!EVP_SignUpdate(ctx, buf.buf, buf.len)) { + PyErr_SetString(_evp_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(blob, &buf); + return NULL; + } + Py_INCREF(Py_None); ++ m2_PyBuffer_Release(blob, &buf); + return Py_None; + } + +@@ -445,24 +467,27 @@ PyObject *sign_final(EVP_MD_CTX *ctx, EVP_PKEY *pkey) { + } + + int verify_update(EVP_MD_CTX *ctx, PyObject *blob) { +- const void *buf; +- Py_ssize_t len; ++ Py_buffer buf; ++ int ret; + +- if (PyObject_AsReadBuffer(blob, &buf, &len) == -1) ++ if (m2_PyObject_GetBuffer(blob, &buf, PyBUF_SIMPLE) == -1) + return -1; +- +- return EVP_VerifyUpdate(ctx, buf, len); ++ ret = EVP_VerifyUpdate(ctx, buf.buf, buf.len); ++ m2_PyBuffer_Release(blob, &buf); ++ return ret; + } + + + int verify_final(EVP_MD_CTX *ctx, PyObject *blob, EVP_PKEY *pkey) { +- unsigned char *kbuf; +- int len; ++ Py_buffer kbuf; ++ int ret; + +- if (m2_PyObject_AsReadBufferInt(blob, (const void **)&kbuf, &len) == -1) ++ if (m2_PyObject_GetBufferInt(blob, &kbuf, PyBUF_SIMPLE) == -1) + return -1; + +- return EVP_VerifyFinal(ctx, kbuf, len, pkey); ++ ret = EVP_VerifyFinal(ctx, (unsigned char *) kbuf.buf, kbuf.len, pkey); ++ m2_PyBuffer_Release(blob, &kbuf); ++ return ret; + } + %} + +diff --git a/SWIG/_lib.i b/SWIG/_lib.i +index 2eaa9fa..890a723 100644 +--- a/SWIG/_lib.i ++++ b/SWIG/_lib.i +@@ -47,33 +47,77 @@ void blob_free(Blob *blob) { + /* Python helpers. */ + + %} +-%ignore m2_PyObject_AsReadBufferInt; ++%ignore PyBuffer_Release; ++%ignore PyObject_CheckBuffer; ++%ignore PyObject_GetBuffer; ++%ignore m2_PyBuffer_Release; ++%ignore m2_PyObject_GetBuffer; ++%ignore m2_PyObject_GetBufferInt; + %ignore m2_PyString_AsStringAndSizeInt; + %{ +-static int +-m2_PyObject_AsReadBufferInt(PyObject *obj, const void **buffer, +- int *buffer_len) +-{ +- int ret; +- Py_ssize_t len; + +- ret = PyObject_AsReadBuffer(obj, buffer, &len); +- if (ret) +- return ret; +- if (len > INT_MAX) { +- PyErr_SetString(PyExc_ValueError, "object too large"); +- return -1; +- } +- *buffer_len = len; ++ ++#if PY_VERSION_HEX < 0x02060000 ++static int PyObject_CheckBuffer(PyObject *obj) { ++ (void)obj; + return 0; + } + ++static int PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { ++ (void)obj; ++ (void)view; ++ (void)flags; ++ return -1; ++} ++ ++static void PyBuffer_Release(Py_buffer *view) { ++ (void)view; ++} ++#endif /* PY_VERSION_HEX < 0x02060000 */ ++ ++ ++static void m2_PyBuffer_Release(PyObject *obj, Py_buffer *view) { ++ if (PyObject_CheckBuffer(obj)) ++ PyBuffer_Release(view); ++ /* else do nothing, view->buf comes from PyObject_AsReadBuffer */ ++} ++ ++static int m2_PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { ++ int ret; ++ ++ if (PyObject_CheckBuffer(obj)) ++ ret = PyObject_GetBuffer(obj, view, flags); ++ else { ++ const void *buf; ++ ++ ret = PyObject_AsReadBuffer(obj, &buf, &view->len); ++ ++ if (ret == 0) ++ view->buf = (void *)buf; ++ } ++ return ret; ++} ++ ++ ++static int m2_PyObject_GetBufferInt(PyObject *obj, Py_buffer *view, int flags) { ++ int ret; ++ ++ ret = m2_PyObject_GetBuffer(obj, view, flags); ++ if (ret) ++ return ret; ++ if (view->len > INT_MAX) { ++ PyErr_SetString(PyExc_ValueError, "object too large"); ++ m2_PyBuffer_Release(obj, view); ++ return -1; ++ } ++ return 0; ++} ++ + static int + m2_PyString_AsStringAndSizeInt(PyObject *obj, char **s, int *len) + { + int ret; + Py_ssize_t len2; +- + ret = PyString_AsStringAndSize(obj, s, &len2); + if (ret) + return ret; +@@ -318,13 +362,15 @@ PyObject *bn_to_mpi(BIGNUM *bn) { + } + + BIGNUM *mpi_to_bn(PyObject *value) { +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; ++ BIGNUM *ret; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- return BN_mpi2bn(vbuf, vlen, NULL); ++ ret = BN_mpi2bn(vbuf.buf, vbuf.len, NULL); ++ m2_PyBuffer_Release(value, &vbuf); ++ return ret; + } + + PyObject *bn_to_bin(BIGNUM *bn) { +@@ -344,13 +390,15 @@ PyObject *bn_to_bin(BIGNUM *bn) { + } + + BIGNUM *bin_to_bn(PyObject *value) { +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; ++ BIGNUM *ret; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- return BN_bin2bn(vbuf, vlen, NULL); ++ ret = BN_bin2bn(vbuf.buf, vbuf.len, NULL); ++ m2_PyBuffer_Release(value, &vbuf); ++ return ret; + } + + PyObject *bn_to_hex(BIGNUM *bn) { +@@ -372,44 +420,48 @@ PyObject *bn_to_hex(BIGNUM *bn) { + } + + BIGNUM *hex_to_bn(PyObject *value) { +- const void *vbuf; +- Py_ssize_t vlen; ++ Py_buffer vbuf; + BIGNUM *bn; + +- if (PyObject_AsReadBuffer(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + + if ((bn=BN_new())==NULL) { + PyErr_SetString(PyExc_MemoryError, "hex_to_bn"); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } +- if (BN_hex2bn(&bn, (const char *)vbuf) <= 0) { ++ if (BN_hex2bn(&bn, (const char *)vbuf.buf) <= 0) { + PyErr_SetString(PyExc_RuntimeError, + ERR_error_string(ERR_get_error(), NULL)); + BN_free(bn); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } ++ m2_PyBuffer_Release(value, &vbuf); + return bn; + } + + BIGNUM *dec_to_bn(PyObject *value) { +- const void *vbuf; +- Py_ssize_t vlen; ++ Py_buffer vbuf; + BIGNUM *bn; + +- if (PyObject_AsReadBuffer(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) == -1) ++ return NULL; + + if ((bn=BN_new())==NULL) { + PyErr_SetString(PyExc_MemoryError, "dec_to_bn"); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } +- if ((BN_dec2bn(&bn, (const char *)vbuf) <= 0)) { ++ if ((BN_dec2bn(&bn, (const char *)vbuf.buf) <= 0)) { + PyErr_SetString(PyExc_RuntimeError, + ERR_error_string(ERR_get_error(), NULL)); + BN_free(bn); ++ m2_PyBuffer_Release(value, &vbuf); + return NULL; + } ++ m2_PyBuffer_Release(value, &vbuf); + return bn; + } + %} +diff --git a/SWIG/_rand.i b/SWIG/_rand.i +index 1a59a90..7e07126 100644 +--- a/SWIG/_rand.i ++++ b/SWIG/_rand.i +@@ -26,25 +26,25 @@ void rand_init(PyObject *rand_err) { + } + + PyObject *rand_seed(PyObject *seed) { +- const void *buf; +- int len; ++ Py_buffer buf; + +- if (m2_PyObject_AsReadBufferInt(seed, &buf, &len) == -1) ++ if (m2_PyObject_GetBufferInt(seed, &buf, PyBUF_SIMPLE) == -1) + return NULL; + +- RAND_seed(buf, len); ++ RAND_seed(buf.buf, buf.len); ++ m2_PyBuffer_Release(seed, &buf); + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *rand_add(PyObject *blob, double entropy) { +- const void *buf; +- int len; ++ Py_buffer buf; + +- if (m2_PyObject_AsReadBufferInt(blob, &buf, &len) == -1) ++ if (m2_PyObject_GetBufferInt(blob, &buf, PyBUF_SIMPLE) == -1) + return NULL; + +- RAND_add(buf, len, entropy); ++ RAND_add(buf.buf, buf.len, entropy); ++ m2_PyBuffer_Release(blob, &buf); + Py_INCREF(Py_None); + return Py_None; + } +diff --git a/SWIG/_rc4.i b/SWIG/_rc4.i +index 42cec17..d3c013a 100644 +--- a/SWIG/_rc4.i ++++ b/SWIG/_rc4.i +@@ -22,33 +22,34 @@ void rc4_free(RC4_KEY *key) { + } + + PyObject *rc4_set_key(RC4_KEY *key, PyObject *value) { +- const void *vbuf; +- int vlen; ++ Py_buffer vbuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) ++ if (m2_PyObject_GetBufferInt(value, &vbuf, PyBUF_SIMPLE) == -1) + return NULL; + +- RC4_set_key(key, vlen, vbuf); ++ RC4_set_key(key, vbuf.len, vbuf.buf); ++ m2_PyBuffer_Release(value, &vbuf); + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *rc4_update(RC4_KEY *key, PyObject *in) { + PyObject *ret; +- const void *buf; +- Py_ssize_t len; + void *out; ++ Py_buffer buf; + +- if (PyObject_AsReadBuffer(in, &buf, &len) == -1) ++ if (m2_PyObject_GetBuffer(in, &buf, PyBUF_SIMPLE) == -1) + return NULL; + +- if (!(out = PyMem_Malloc(len))) { ++ if (!(out = PyMem_Malloc(buf.len))) { + PyErr_SetString(PyExc_MemoryError, "expected a string object"); ++ m2_PyBuffer_Release(in, &buf); + return NULL; + } +- RC4(key, len, buf, out); +- ret = PyString_FromStringAndSize(out, len); ++ RC4(key, buf.len, buf.buf, out); ++ ret = PyString_FromStringAndSize(out, buf.len); + PyMem_Free(out); ++ m2_PyBuffer_Release(in, &buf); + return ret; + } + +diff --git a/SWIG/_rsa.i b/SWIG/_rsa.i +index af91c5c..22bb55d 100644 +--- a/SWIG/_rsa.i ++++ b/SWIG/_rsa.i +@@ -120,18 +120,19 @@ PyObject *rsa_get_n(RSA *rsa) { + + PyObject *rsa_set_e(RSA *rsa, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &pybuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_mpi2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_mpi2bn((unsigned char *)pybuf.buf, pybuf.len, NULL))) { + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &pybuf); + return NULL; + } + if (rsa->e) + BN_free(rsa->e); ++ m2_PyBuffer_Release(value, &pybuf); + rsa->e = bn; + Py_INCREF(Py_None); + return Py_None; +@@ -139,18 +140,19 @@ PyObject *rsa_set_e(RSA *rsa, PyObject *value) { + + PyObject *rsa_set_n(RSA *rsa, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &pybuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_mpi2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_mpi2bn((unsigned char *)pybuf.buf, pybuf.len, NULL))) { + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &pybuf); + return NULL; + } + if (rsa->n) + BN_free(rsa->n); ++ m2_PyBuffer_Release(value, &pybuf); + rsa->n = bn; + Py_INCREF(Py_None); + return Py_None; +@@ -158,18 +160,19 @@ PyObject *rsa_set_n(RSA *rsa, PyObject *value) { + + PyObject *rsa_set_e_bin(RSA *rsa, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &pybuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_bin2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_bin2bn((unsigned char *)pybuf.buf, pybuf.len, NULL))) { + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &pybuf); + return NULL; + } + if (rsa->e) + BN_free(rsa->e); ++ m2_PyBuffer_Release(value, &pybuf); + rsa->e = bn; + Py_INCREF(Py_None); + return Py_None; +@@ -177,178 +180,196 @@ PyObject *rsa_set_e_bin(RSA *rsa, PyObject *value) { + + PyObject *rsa_set_n_bin(RSA *rsa, PyObject *value) { + BIGNUM *bn; +- const void *vbuf; +- int vlen; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(value, &vbuf, &vlen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(value, &pybuf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- if (!(bn = BN_bin2bn((unsigned char *)vbuf, vlen, NULL))) { ++ if (!(bn = BN_bin2bn((unsigned char *)pybuf.buf, pybuf.len, NULL))) { + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(value, &pybuf); + return NULL; + } + if (rsa->n) + BN_free(rsa->n); ++ m2_PyBuffer_Release(value, &pybuf); + rsa->n = bn; + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *rsa_private_encrypt(RSA *rsa, PyObject *from, int padding) { +- const void *fbuf; + void *tbuf; +- int flen, tlen; ++ int tlen; + PyObject *ret; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(from, &fbuf, &flen) == -1) +- return NULL; ++ if (m2_PyObject_GetBufferInt(from, &pybuf, PyBUF_SIMPLE) == -1) ++ return NULL; + + if (!(tbuf = PyMem_Malloc(BN_num_bytes(rsa->n)))) { + PyErr_SetString(PyExc_MemoryError, "rsa_private_encrypt"); ++ m2_PyBuffer_Release(from, &pybuf); + return NULL; + } +- tlen = RSA_private_encrypt(flen, (unsigned char *)fbuf, +- (unsigned char *)tbuf, rsa, padding); ++ tlen = RSA_private_encrypt(pybuf.len, (unsigned char *)pybuf.buf, ++ (unsigned char *)tbuf, rsa, padding); + if (tlen == -1) { + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); + return NULL; + } + ret = PyString_FromStringAndSize((const char *)tbuf, tlen); + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + return ret; + } + + PyObject *rsa_public_decrypt(RSA *rsa, PyObject *from, int padding) { +- const void *fbuf; + void *tbuf; +- int flen, tlen; ++ int tlen; + PyObject *ret; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(from, &fbuf, &flen) == -1) ++ if (m2_PyObject_GetBufferInt(from, &pybuf, PyBUF_SIMPLE) == -1) + return NULL; + + if (!(tbuf = PyMem_Malloc(BN_num_bytes(rsa->n)))) { + PyErr_SetString(PyExc_MemoryError, "rsa_public_decrypt"); ++ m2_PyBuffer_Release(from, &pybuf); + return NULL; + } +- tlen = RSA_public_decrypt(flen, (unsigned char *)fbuf, +- (unsigned char *)tbuf, rsa, padding); ++ tlen = RSA_public_decrypt(pybuf.len, (unsigned char *)pybuf.buf, ++ (unsigned char *)tbuf, rsa, padding); + if (tlen == -1) { + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); + return NULL; + } + ret = PyString_FromStringAndSize((const char *)tbuf, tlen); + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + return ret; + } + + PyObject *rsa_public_encrypt(RSA *rsa, PyObject *from, int padding) { +- const void *fbuf; + void *tbuf; +- int flen, tlen; ++ int tlen; + PyObject *ret; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(from, &fbuf, &flen) == -1) ++ if (m2_PyObject_GetBufferInt(from, &pybuf, PyBUF_SIMPLE) == -1) + return NULL; + + if (!(tbuf = PyMem_Malloc(BN_num_bytes(rsa->n)))) { + PyErr_SetString(PyExc_MemoryError, "rsa_public_encrypt"); ++ m2_PyBuffer_Release(from, &pybuf); + return NULL; + } +- tlen = RSA_public_encrypt(flen, (unsigned char *)fbuf, ++ tlen = RSA_public_encrypt(pybuf.len, (unsigned char *)pybuf.buf, + (unsigned char *)tbuf, rsa, padding); + if (tlen == -1) { + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); + return NULL; + } + ret = PyString_FromStringAndSize((const char *)tbuf, tlen); + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + return ret; + } + + PyObject *rsa_private_decrypt(RSA *rsa, PyObject *from, int padding) { +- const void *fbuf; + void *tbuf; +- int flen, tlen; ++ int tlen; + PyObject *ret; ++ Py_buffer pybuf; + +- if (m2_PyObject_AsReadBufferInt(from, &fbuf, &flen) == -1) ++ if (m2_PyObject_GetBufferInt(from, &pybuf, PyBUF_SIMPLE) == -1) + return NULL; + + if (!(tbuf = PyMem_Malloc(BN_num_bytes(rsa->n)))) { + PyErr_SetString(PyExc_MemoryError, "rsa_private_decrypt"); ++ m2_PyBuffer_Release(from, &pybuf); + return NULL; + } +- tlen = RSA_private_decrypt(flen, (unsigned char *)fbuf, +- (unsigned char *)tbuf, rsa, padding); ++ tlen = RSA_private_decrypt(pybuf.len, (unsigned char *)pybuf.buf, ++ (unsigned char *)tbuf, rsa, padding); ++ + if (tlen == -1) { + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); + return NULL; + } + ret = PyString_FromStringAndSize((const char *)tbuf, tlen); + PyMem_Free(tbuf); ++ m2_PyBuffer_Release(from, &pybuf); + return ret; + } + + #if OPENSSL_VERSION_NUMBER >= 0x0090708fL + PyObject *rsa_padding_add_pkcs1_pss(RSA *rsa, PyObject *digest, EVP_MD *hash, int salt_length) { +- const void *dbuf; + unsigned char *tbuf; +- int dlen, result, tlen; ++ int result, tlen; + PyObject *ret; ++ Py_buffer dbuf; + +- if (m2_PyObject_AsReadBufferInt(digest, &dbuf, &dlen) == -1) ++ if (m2_PyObject_GetBufferInt(digest, &dbuf, PyBUF_SIMPLE) == -1) + return NULL; + + tlen = RSA_size(rsa); + + if (!(tbuf = OPENSSL_malloc(tlen))) { + PyErr_SetString(PyExc_MemoryError, "rsa_padding_add_pkcs1_pss"); ++ m2_PyBuffer_Release(digest, &dbuf); + return NULL; + } + result = RSA_padding_add_PKCS1_PSS( + rsa, + tbuf, +- (unsigned char *)dbuf, ++ (unsigned char *)dbuf.buf, + hash, + salt_length); + + if (result == -1) { + OPENSSL_cleanse(tbuf, tlen); + OPENSSL_free(tbuf); ++ m2_PyBuffer_Release(digest, &dbuf); + PyErr_SetString(_rsa_err, ERR_reason_error_string(ERR_get_error())); + return NULL; + } + ret = PyString_FromStringAndSize((const char *)tbuf, tlen); + OPENSSL_cleanse(tbuf, tlen); + OPENSSL_free(tbuf); ++ m2_PyBuffer_Release(digest, &dbuf); + return ret; + } + + int rsa_verify_pkcs1_pss(RSA *rsa, PyObject *digest, PyObject *signature, EVP_MD *hash, int salt_length) { +- const void *dbuf; +- const void *sbuf; +- int dlen, slen, ret; ++ int ret; ++ Py_buffer dbuf, sbuf; + +- if (m2_PyObject_AsReadBufferInt(digest, &dbuf, &dlen) == -1) { ++ if (m2_PyObject_GetBufferInt(digest, &dbuf, PyBUF_SIMPLE) == -1) { + return 0; + } +- +- if (m2_PyObject_AsReadBufferInt(signature, &sbuf, &slen) == -1) { ++ if (m2_PyObject_GetBufferInt(signature, &sbuf, PyBUF_SIMPLE) == -1) { ++ m2_PyBuffer_Release(digest, &dbuf); + return 0; + } + + ret = RSA_verify_PKCS1_PSS( + rsa, +- (unsigned char *)dbuf, ++ (unsigned char *)dbuf.buf, + hash, +- (unsigned char *)sbuf, ++ (unsigned char *)sbuf.buf, + salt_length); + ++ m2_PyBuffer_Release(digest, &dbuf); ++ m2_PyBuffer_Release(signature, &sbuf); + return ret; + } + #endif +diff --git a/SWIG/_ssl.i b/SWIG/_ssl.i +index 28a247c..e0856af 100644 +--- a/SWIG/_ssl.i ++++ b/SWIG/_ssl.i +@@ -315,13 +315,14 @@ void ssl_ctx_set_verify(SSL_CTX *ctx, int mode, PyObject *pyfunc) { + } + + int ssl_ctx_set_session_id_context(SSL_CTX *ctx, PyObject *sid_ctx) { +- const void *buf; +- int len; +- +- if (m2_PyObject_AsReadBufferInt(sid_ctx, &buf, &len) == -1) +- return -1; ++ Py_buffer buf; ++ int ret; + +- return SSL_CTX_set_session_id_context(ctx, buf, len); ++ if (m2_PyObject_GetBufferInt(sid_ctx, &buf, PyBUF_SIMPLE) == -1) ++ return -1; ++ ret = SSL_CTX_set_session_id_context(ctx, buf.buf, buf.len); ++ m2_PyBuffer_Release(sid_ctx, &buf); ++ return ret; + } + + void ssl_ctx_set_info_callback(SSL_CTX *ctx, PyObject *pyfunc) { +@@ -384,13 +385,15 @@ void ssl_set_client_CA_list_from_context(SSL *ssl, SSL_CTX *ctx) { + } + + int ssl_set_session_id_context(SSL *ssl, PyObject *sid_ctx) { +- const void *buf; +- int len; ++ Py_buffer buf; ++ int ret; + +- if (m2_PyObject_AsReadBufferInt(sid_ctx, &buf, &len) == -1) +- return -1; ++ if (m2_PyObject_GetBufferInt(sid_ctx, &buf, PyBUF_SIMPLE) == -1) ++ return -1; + +- return SSL_set_session_id_context(ssl, buf, len); ++ ret = SSL_set_session_id_context(ssl, buf.buf, buf.len); ++ m2_PyBuffer_Release(sid_ctx, &buf); ++ return ret; + } + + int ssl_set_fd(SSL *ssl, int fd) { +@@ -583,17 +586,14 @@ PyObject *ssl_read_nbio(SSL *ssl, int num) { + } + + int ssl_write(SSL *ssl, PyObject *blob) { +- const void *buf; +- int len, r, err, ret; +- ++ int r, err, ret; ++ Py_buffer buf; + +- if (m2_PyObject_AsReadBufferInt(blob, &buf, &len) == -1) { ++ if (m2_PyObject_GetBufferInt(blob, &buf, PyBUF_SIMPLE) == -1) + return -1; +- } + +- + Py_BEGIN_ALLOW_THREADS +- r = SSL_write(ssl, buf, len); ++ r = SSL_write(ssl, buf.buf, buf.len); + Py_END_ALLOW_THREADS + + +@@ -623,22 +623,19 @@ int ssl_write(SSL *ssl, PyObject *blob) { + ret = -1; + } + +- ++ m2_PyBuffer_Release(blob, &buf); + return ret; + } + + int ssl_write_nbio(SSL *ssl, PyObject *blob) { +- const void *buf; +- int len, r, err, ret; +- ++ int r, err, ret; ++ Py_buffer buf; + +- if (m2_PyObject_AsReadBufferInt(blob, &buf, &len) == -1) { ++ if (m2_PyObject_GetBufferInt(blob, &buf, PyBUF_SIMPLE) == -1) + return -1; +- } +- + + Py_BEGIN_ALLOW_THREADS +- r = SSL_write(ssl, buf, len); ++ r = SSL_write(ssl, buf.buf, buf.len); + Py_END_ALLOW_THREADS + + +@@ -667,7 +664,7 @@ int ssl_write_nbio(SSL *ssl, PyObject *blob) { + ret = -1; + } + +- ++ m2_PyBuffer_Release(blob, &buf); + return ret; + } + +diff --git a/SWIG/_util.i b/SWIG/_util.i +index c1105eb..f1f0a74 100644 +--- a/SWIG/_util.i ++++ b/SWIG/_util.i +@@ -17,41 +17,43 @@ void util_init(PyObject *util_err) { + + PyObject *util_hex_to_string(PyObject *blob) { + PyObject *obj; +- const void *buf; + char *ret; +- Py_ssize_t len; ++ Py_buffer buf; + +- if (PyObject_AsReadBuffer(blob, &buf, &len) == -1) +- return NULL; ++ if (m2_PyObject_GetBuffer(blob, &buf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- ret = hex_to_string((unsigned char *)buf, len); ++ ret = hex_to_string((unsigned char *)buf.buf, buf.len); + if (!ret) { + PyErr_SetString(_util_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(blob, &buf); + return NULL; + } + obj = PyString_FromString(ret); + OPENSSL_free(ret); ++ m2_PyBuffer_Release(blob, &buf); + return obj; + } + + PyObject *util_string_to_hex(PyObject *blob) { + PyObject *obj; +- const void *buf; + unsigned char *ret; +- Py_ssize_t len0; + long len; ++ Py_buffer buf; + +- if (PyObject_AsReadBuffer(blob, &buf, &len0) == -1) +- return NULL; ++ if (m2_PyObject_GetBuffer(blob, &buf, PyBUF_SIMPLE) == -1) ++ return NULL; + +- len = len0; +- ret = string_to_hex((char *)buf, &len); ++ len = buf.len; ++ ret = string_to_hex((char *)buf.buf, &len); + if (ret == NULL) { + PyErr_SetString(_util_err, ERR_reason_error_string(ERR_get_error())); ++ m2_PyBuffer_Release(blob, &buf); + return NULL; + } + obj = PyString_FromStringAndSize((char*)ret, len); + OPENSSL_free(ret); ++ m2_PyBuffer_Release(blob, &buf); + return obj; + } + %} +-- +2.4.1 + diff --git a/dev-python/m2crypto/files/0.21.1-0003-Use-swig-generated-python-loader.patch b/dev-python/m2crypto/files/0.21.1-0003-Use-swig-generated-python-loader.patch new file mode 100644 index 000000000000..95d183daabfe --- /dev/null +++ b/dev-python/m2crypto/files/0.21.1-0003-Use-swig-generated-python-loader.patch @@ -0,0 +1,165 @@ +From a0b19d256e834b77fc414b162bc86eabb06d516c Mon Sep 17 00:00:00 2001 +From: Joe Julian <jjulian@io.com> +Date: Tue, 19 May 2015 23:54:08 -0700 +Subject: [PATCH 3/3] Use swig generated python loader + +--- + M2Crypto/__init__.py | 4 ++-- + M2Crypto/m2.py | 4 +--- + SWIG/Makefile | 4 ++-- + SWIG/_m2crypto.def | 2 +- + SWIG/_m2crypto.i | 2 +- + pack.py | 4 ++-- + setup.py | 28 +++++++++++++++++++++++----- + 7 files changed, 32 insertions(+), 16 deletions(-) + +diff --git a/M2Crypto/__init__.py b/M2Crypto/__init__.py +index e7acfe7..84d90e3 100644 +--- a/M2Crypto/__init__.py ++++ b/M2Crypto/__init__.py +@@ -19,7 +19,7 @@ Copyright 2008-2011 Heikki Toivonen. All rights reserved. + version_info = (0, 21, 1) + version = '.'.join([str(_v) for _v in version_info]) + +-import __m2crypto ++import m2crypto + import m2 + import ASN1 + import AuthCookie +@@ -57,4 +57,4 @@ import util + encrypt=1 + decrypt=0 + +-__m2crypto.lib_init() ++m2crypto.lib_init() +diff --git a/M2Crypto/m2.py b/M2Crypto/m2.py +index e4bb695..516cadb 100644 +--- a/M2Crypto/m2.py ++++ b/M2Crypto/m2.py +@@ -25,7 +25,5 @@ Portions created by Open Source Applications Foundation (OSAF) are + Copyright (C) 2004 OSAF. All Rights Reserved. + """ + +-from __m2crypto import * ++from m2crypto import * + lib_init() +- +- +diff --git a/SWIG/Makefile b/SWIG/Makefile +index 505b940..a840955 100644 +--- a/SWIG/Makefile ++++ b/SWIG/Makefile +@@ -17,8 +17,8 @@ all: _m2crypto + _m2crypto: _m2crypto.i + swig -python -shadow _m2crypto.i + cc -c -fpic $(CFLAGS) $(INCLUDE) $(PYINCLUDE) _m2crypto_wrap.c +- ld -Bshareable -o __m2crypto.so _m2crypto_wrap.o $(LIBS) +- cp _m2crypto.py __m2crypto.so ../M2Crypto ++ ld -Bshareable -o _m2crypto.so _m2crypto_wrap.o $(LIBS) ++ cp m2crypto.py _m2crypto.so ../M2Crypto + + clean: + rm -f *_wrap* *.o *.so _*.py *.pyc +diff --git a/SWIG/_m2crypto.def b/SWIG/_m2crypto.def +index 753db2c..3e9d5bc 100644 +--- a/SWIG/_m2crypto.def ++++ b/SWIG/_m2crypto.def +@@ -1,2 +1,2 @@ + EXPORTS
+-init__m2crypto ++init_m2crypto +diff --git a/SWIG/_m2crypto.i b/SWIG/_m2crypto.i +index 3d779a1..f236536 100644 +--- a/SWIG/_m2crypto.i ++++ b/SWIG/_m2crypto.i +@@ -8,7 +8,7 @@ + * + */ + +-%module(threads=1) _m2crypto ++%module(threads=1) m2crypto + /* We really don't need threadblock (PyGILState_Ensure() etc.) anywhere. + Disable threadallow as well, only enable it for operations likely to + block. */ +diff --git a/pack.py b/pack.py +index 0005026..14b4961 100644 +--- a/pack.py ++++ b/pack.py +@@ -17,9 +17,9 @@ if __name__ == "__main__": + os.path.walk(start, zap, "/*.pyc") + + if os.name == 'nt': +- zap_m2 = ("__m2cryptoc.pyd","_m2crypto.py") ++ zap_m2 = ("_m2cryptoc.pyd","m2crypto.py") + elif os.name == 'posix': +- zap_m2 = ("__m2crypto.so","_m2crypto.py") ++ zap_m2 = ("_m2crypto.so","m2crypto.py") + for x in zap_m2: + try: + os.remove("%s/M2Crypto/%s" % (start, x)) +diff --git a/setup.py b/setup.py +index e7c49eb..0967216 100644 +--- a/setup.py ++++ b/setup.py +@@ -19,8 +19,21 @@ except ImportError: + from distutils.core import setup + from distutils.command import build_ext + ++from distutils.util import get_platform + from distutils.core import Extension + ++from distutils.command.build import build ++from setuptools.command.install import install ++ ++class CustomBuild(build): ++ def run(self): ++ self.run_command('build_ext') ++ build.run(self) ++ ++class CustomInstall(install): ++ def run(self): ++ self.run_command('build_ext') ++ self.do_egg_install() + + class _M2CryptoBuildExt(build_ext.build_ext): + '''Specialization of build_ext to enable swig_opts to inherit any +@@ -49,12 +62,17 @@ class _M2CryptoBuildExt(build_ext.build_ext): + + build_ext.build_ext.finalize_options(self) + +- opensslIncludeDir = os.path.join(self.openssl, 'include') ++ includeDir = os.path.join(self.openssl, 'include') ++ opensslIncludeDir = os.path.join(self.openssl, 'include', 'openssl') + opensslLibraryDir = os.path.join(self.openssl, 'lib') + + self.swig_opts = ['-I%s' % i for i in self.include_dirs + \ +- [opensslIncludeDir]] +- self.swig_opts.append('-includeall') ++ [opensslIncludeDir, includeDir]] ++ if get_platform() == 'linux-x86_64': ++ self.swig_opts.append('-D__x86_64__') ++ self.swig_opts.append('-outdir') ++ self.swig_opts.append(os.path.join(os.getcwd(),'M2Crypto')) ++ #self.swig_opts.append('-includeall') + #self.swig_opts.append('-D__i386__') # Uncomment for early OpenSSL 0.9.7 versions, or on Fedora Core if build fails + #self.swig_opts.append('-DOPENSSL_NO_EC') # Try uncommenting if you can't build with EC disabled + +@@ -127,7 +145,7 @@ if sys.version_info < (2,4): + build_ext.build_ext.swig_sources = swig_sources + + +-m2crypto = Extension(name = 'M2Crypto.__m2crypto', ++m2crypto = Extension(name = 'M2Crypto._m2crypto', + sources = ['SWIG/_m2crypto.i'], + extra_compile_args = ['-DTHREADING'], + #extra_link_args = ['-Wl,-search_paths_first'], # Uncomment to build Universal Mac binaries +@@ -164,5 +182,5 @@ used to provide SSL for Twisted.''', + + ext_modules = [m2crypto], + test_suite='tests.alltests.suite', +- cmdclass = {'build_ext': _M2CryptoBuildExt} ++ cmdclass = {'build': CustomBuild, 'install': CustomInstall, 'build_ext': _M2CryptoBuildExt} + ) +-- +2.4.1 + diff --git a/dev-python/m2crypto/files/0.21.1-packaging.patch b/dev-python/m2crypto/files/0.21.1-packaging.patch new file mode 100644 index 000000000000..0ea16fbd9096 --- /dev/null +++ b/dev-python/m2crypto/files/0.21.1-packaging.patch @@ -0,0 +1,56 @@ +From 017d82b1f17446f38339589e25e9aba98f87f9f4 Mon Sep 17 00:00:00 2001 +From: Mike Gilbert <floppym@gentoo.org> +Date: Mon, 25 May 2015 13:09:35 -0400 +Subject: [PATCH] Gentoo-specific packaging fixes + +Fix cross-compiles +EPREFIX support +Revert custom build and install classes +--- + setup.py | 11 ++++------- + 1 file changed, 4 insertions(+), 7 deletions(-) + +diff --git a/setup.py b/setup.py +index 0967216..bca474a 100644 +--- a/setup.py ++++ b/setup.py +@@ -66,8 +66,8 @@ class _M2CryptoBuildExt(build_ext.build_ext): + opensslIncludeDir = os.path.join(self.openssl, 'include', 'openssl') + opensslLibraryDir = os.path.join(self.openssl, 'lib') + +- self.swig_opts = ['-I%s' % i for i in self.include_dirs + \ +- [opensslIncludeDir, includeDir]] ++ eprefix = os.getenv('EPREFIX', '') ++ self.swig_opts = ['-I' + eprefix + '/usr/include'] + if get_platform() == 'linux-x86_64': + self.swig_opts.append('-D__x86_64__') + self.swig_opts.append('-outdir') +@@ -76,8 +76,7 @@ class _M2CryptoBuildExt(build_ext.build_ext): + #self.swig_opts.append('-D__i386__') # Uncomment for early OpenSSL 0.9.7 versions, or on Fedora Core if build fails + #self.swig_opts.append('-DOPENSSL_NO_EC') # Try uncommenting if you can't build with EC disabled + +- self.include_dirs += [os.path.join(self.openssl, opensslIncludeDir), +- os.path.join(os.getcwd(), 'SWIG')] ++ self.include_dirs += [os.path.join(os.getcwd(), 'SWIG')] + + if sys.platform == 'cygwin': + # Cygwin SHOULD work (there's code in distutils), but +@@ -87,8 +86,6 @@ class _M2CryptoBuildExt(build_ext.build_ext): + # Someday distutils will be fixed and this won't be needed. + self.library_dirs += [os.path.join(self.openssl, 'bin')] + +- self.library_dirs += [os.path.join(self.openssl, opensslLibraryDir)] +- + + if sys.version_info < (2,4): + +@@ -182,5 +179,5 @@ used to provide SSL for Twisted.''', + + ext_modules = [m2crypto], + test_suite='tests.alltests.suite', +- cmdclass = {'build': CustomBuild, 'install': CustomInstall, 'build_ext': _M2CryptoBuildExt} ++ cmdclass = {'build_ext': _M2CryptoBuildExt} + ) +-- +2.4.1 + diff --git a/dev-python/m2crypto/m2crypto-0.21.1-r3.ebuild b/dev-python/m2crypto/m2crypto-0.21.1-r3.ebuild new file mode 100644 index 000000000000..5af61edac5d3 --- /dev/null +++ b/dev-python/m2crypto/m2crypto-0.21.1-r3.ebuild @@ -0,0 +1,46 @@ +# Copyright 1999-2015 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/dev-python/m2crypto/m2crypto-0.21.1-r3.ebuild,v 1.1 2015/05/25 17:16:54 floppym Exp $ + +EAPI=5 + +PYTHON_COMPAT=( python2_7 ) +PYTHON_REQ_USE="threads(+)" + +inherit distutils-r1 + +MY_PN="M2Crypto" + +DESCRIPTION="M2Crypto: A Python crypto and SSL toolkit" +HOMEPAGE="http://chandlerproject.org/bin/view/Projects/MeTooCrypto http://pypi.python.org/pypi/M2Crypto" +SRC_URI="mirror://pypi/${MY_PN:0:1}/${MY_PN}/${MY_PN}-${PV}.tar.gz" + +LICENSE="BSD" +SLOT="0" +KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos" +IUSE="doc examples" + +# swig-3.0.5 results in broken constants, #538920 +RDEPEND=">=dev-libs/openssl-0.9.8:0=" +DEPEND="${RDEPEND} + <dev-lang/swig-3.0.5 + >=dev-lang/swig-1.3.28 + dev-python/setuptools[${PYTHON_USEDEP}] + doc? ( dev-python/epydoc[${PYTHON_USEDEP}] )" + +S="${WORKDIR}/${MY_PN}-${PV}" + +# Tests access network, and fail randomly. Bug #431458. +RESTRICT=test + +PATCHES=( + 0.21.1-0001-Fixed-invalid-variable-name.patch + 0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch + 0.21.1-0003-Use-swig-generated-python-loader.patch + 0.21.1-packaging.patch +) +PATCHES=( "${PATCHES[@]/#/${FILESDIR}/}" ) + +python_test() { + esetup.py test +} |