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 <[email protected]>
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 <[email protected]>
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 <[email protected]>
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 <[email protected]>
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
