floppym 15/05/25 17:16:54 Added: 0.21.1-0003-Use-swig-generated-python-loader.patch 0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch 0.21.1-packaging.patch 0.21.1-0001-Fixed-invalid-variable-name.patch Log: Resolve issues with swig-3.0.5 in the older 0.21 fork as well. (Portage version: 2.2.20/cvs/Linux x86_64, signed Manifest commit with key 0BBEEA1FEA4843A4)
Revision Changes Path 1.1 dev-python/m2crypto/files/0.21.1-0003-Use-swig-generated-python-loader.patch file : http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-0003-Use-swig-generated-python-loader.patch?rev=1.1&view=markup plain: http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-0003-Use-swig-generated-python-loader.patch?rev=1.1&content-type=text/plain Index: 0.21.1-0003-Use-swig-generated-python-loader.patch =================================================================== >From a0b19d256e834b77fc414b162bc86eabb06d516c Mon Sep 17 00:00:00 2001 From: Joe Julian <jjul...@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 1.1 dev-python/m2crypto/files/0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch file : http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch?rev=1.1&view=markup plain: http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch?rev=1.1&content-type=text/plain Index: 0.21.1-0002-Fixing-memory-leaks-in-the-SWIG-wrapper.patch =================================================================== >From 452d50d64a8e3368fe93db561a14a7bd14ca1b3c Mon Sep 17 00:00:00 2001 From: Andreas Moser <amo...@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 1.1 dev-python/m2crypto/files/0.21.1-packaging.patch file : http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-packaging.patch?rev=1.1&view=markup plain: http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-packaging.patch?rev=1.1&content-type=text/plain Index: 0.21.1-packaging.patch =================================================================== >From 017d82b1f17446f38339589e25e9aba98f87f9f4 Mon Sep 17 00:00:00 2001 From: Mike Gilbert <flop...@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 1.1 dev-python/m2crypto/files/0.21.1-0001-Fixed-invalid-variable-name.patch file : http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-0001-Fixed-invalid-variable-name.patch?rev=1.1&view=markup plain: http://sources.gentoo.org/viewvc.cgi/gentoo-x86/dev-python/m2crypto/files/0.21.1-0001-Fixed-invalid-variable-name.patch?rev=1.1&content-type=text/plain Index: 0.21.1-0001-Fixed-invalid-variable-name.patch =================================================================== >From 3afe5a15df02bce629051e67a691f2b21ce3cfa7 Mon Sep 17 00:00:00 2001 From: Hugo Castilho <hugo.p.casti...@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