#include "Python.h"

#ifdef WITH_THREAD

#include "pythread.h"

#define PySSL_BEGIN_ALLOW_THREADS_S(save) \

do { if (_ssl_locks_count>0) { (save) = PyEval_SaveThread(); } } while (0)

#define PySSL_END_ALLOW_THREADS_S(save) \

do { if (_ssl_locks_count>0) { PyEval_RestoreThread(save); } } while (0)

#define PySSL_BEGIN_ALLOW_THREADS { \

PyThreadState *_save = NULL; \

PySSL_BEGIN_ALLOW_THREADS_S(_save);

#define PySSL_BLOCK_THREADS PySSL_END_ALLOW_THREADS_S(_save);

#define PySSL_UNBLOCK_THREADS PySSL_BEGIN_ALLOW_THREADS_S(_save);

#define PySSL_END_ALLOW_THREADS PySSL_END_ALLOW_THREADS_S(_save); }

#else /* no WITH_THREAD */

#define PySSL_BEGIN_ALLOW_THREADS_S(save)

#define PySSL_END_ALLOW_THREADS_S(save)

#define PySSL_BEGIN_ALLOW_THREADS

#define PySSL_BLOCK_THREADS

#define PySSL_UNBLOCK_THREADS

#define PySSL_END_ALLOW_THREADS

enum py_ssl_error {

};

enum py_ssl_server_or_client {

PY_SSL_CLIENT,

PY_SSL_SERVER

};

enum py_ssl_cert_requirements {

};

enum py_ssl_version {

};

struct py_ssl_error_code {

const char *mnemonic;

int library, reason;

};

struct py_ssl_library_code {

const char *library;

int code;

};

#include "socketmodule.h"

static PySocketModule_APIObject PySocketModule;

#if defined(HAVE_POLL_H)

#include <poll.h>

#elif defined(HAVE_SYS_POLL_H)

#include <sys/poll.h>

#include "openssl/rsa.h"

#include "openssl/crypto.h"

#include "openssl/x509.h"

#include "openssl/x509v3.h"

#include "openssl/pem.h"

#include "openssl/ssl.h"

#include "openssl/err.h"

#include "openssl/rand.h"

#include "_ssl_data.h"

static PyObject *PySSLErrorObject;

static PyObject *PySSLZeroReturnErrorObject;

static PyObject *PySSLWantReadErrorObject;

static PyObject *PySSLWantWriteErrorObject;

static PyObject *PySSLSyscallErrorObject;

static PyObject *PySSLEOFErrorObject;

static PyObject *err_codes_to_names;

static PyObject *err_names_to_codes;

static PyObject *lib_codes_to_names;

#ifdef WITH_THREAD

static unsigned int _ssl_locks_count = 0;

#endif /* def WITH_THREAD */

#define X509_NAME_MAXLEN 256

#if OPENSSL_VERSION_NUMBER >= 0x0090500fL

# define HAVE_OPENSSL_RAND 1

# undef HAVE_OPENSSL_RAND

#if OPENSSL_VERSION_NUMBER >= 0x009080dfL && OPENSSL_VERSION_NUMBER != 0x00909000L

# define HAVE_SSL_CTX_CLEAR_OPTIONS

# undef HAVE_SSL_CTX_CLEAR_OPTIONS

#define PySSL_CB_MAXLEN 128

#if OPENSSL_VERSION_NUMBER >= 0x0090500fL

# define HAVE_OPENSSL_FINISHED 1

# define HAVE_OPENSSL_FINISHED 0

#if OPENSSL_VERSION_NUMBER < 0x0090800fL && !defined(OPENSSL_NO_ECDH)

# define OPENSSL_NO_ECDH

#if OPENSSL_VERSION_NUMBER < 0x0090800fL && !defined(OPENSSL_NO_COMP)

# define OPENSSL_NO_COMP

typedef struct {

PyObject_HEAD

SSL_CTX *ctx;

#ifdef OPENSSL_NPN_NEGOTIATED

char *npn_protocols;

int npn_protocols_len;

} PySSLContext;

typedef struct {

PyObject_HEAD

PyObject *Socket; /* weakref to socket on which we're layered */

SSL *ssl;

X509 *peer_cert;

int shutdown_seen_zero;

enum py_ssl_server_or_client socket_type;

} PySSLSocket;

static PyTypeObject PySSLContext_Type;

static PyTypeObject PySSLSocket_Type;

static PyObject *PySSL_SSLwrite(PySSLSocket *self, PyObject *args);

static PyObject *PySSL_SSLread(PySSLSocket *self, PyObject *args);

static int check_socket_and_wait_for_timeout(PySocketSockObject *s,

int writing);

static PyObject *PySSL_peercert(PySSLSocket *self, PyObject *args);

static PyObject *PySSL_cipher(PySSLSocket *self);

#define PySSLContext_Check(v) (Py_TYPE(v) == &PySSLContext_Type)

#define PySSLSocket_Check(v) (Py_TYPE(v) == &PySSLSocket_Type)

typedef enum {

SOCKET_IS_NONBLOCKING,

SOCKET_IS_BLOCKING,

SOCKET_HAS_TIMED_OUT,

SOCKET_HAS_BEEN_CLOSED,

SOCKET_TOO_LARGE_FOR_SELECT,

SOCKET_OPERATION_OK

} timeout_state;

#define STRINGIFY1(x) #x

#define STRINGIFY2(x) STRINGIFY1(x)

#define ERRSTR1(x,y,z) (x ":" y ": " z)

#define ERRSTR(x) ERRSTR1("_ssl.c", STRINGIFY2(__LINE__), x)

PyDoc_STRVAR(SSLError_doc,

"An error occurred in the SSL implementation.");

PyDoc_STRVAR(SSLZeroReturnError_doc,

"SSL/TLS session closed cleanly.");

PyDoc_STRVAR(SSLWantReadError_doc,

"before the requested operation can be completed.");

PyDoc_STRVAR(SSLWantWriteError_doc,

"before the requested operation can be completed.");

PyDoc_STRVAR(SSLSyscallError_doc,

"System error when attempting SSL operation.");

PyDoc_STRVAR(SSLEOFError_doc,

"SSL/TLS connection terminated abruptly.");

static PyObject *

SSLError_str(PyOSErrorObject *self)

{

if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {

Py_INCREF(self->strerror);

return self->strerror;

}

else

return PyObject_Str(self->args);

}

static PyType_Slot sslerror_type_slots[] = {

{Py_tp_base, NULL}, /* Filled out in module init as it's not a constant */

{Py_tp_doc, SSLError_doc},

{Py_tp_str, SSLError_str},

{0, 0},

};

static PyType_Spec sslerror_type_spec = {

"ssl.SSLError",

sizeof(PyOSErrorObject),

0,

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,

sslerror_type_slots

};

static void

fill_and_set_sslerror(PyObject *type, int ssl_errno, const char *errstr,

int lineno, unsigned long errcode)

{

PyObject *err_value = NULL, *reason_obj = NULL, *lib_obj = NULL;

PyObject *init_value, *msg, *key;

_Py_IDENTIFIER(reason);

_Py_IDENTIFIER(library);

if (errcode != 0) {

int lib, reason;

lib = ERR_GET_LIB(errcode);

reason = ERR_GET_REASON(errcode);

key = Py_BuildValue("ii", lib, reason);

if (key == NULL)

goto fail;

reason_obj = PyDict_GetItem(err_codes_to_names, key);

Py_DECREF(key);

if (reason_obj == NULL) {

/* XXX if reason < 100, it might reflect a library number (!!) */

PyErr_Clear();

}

key = PyLong_FromLong(lib);

if (key == NULL)

goto fail;

lib_obj = PyDict_GetItem(lib_codes_to_names, key);

Py_DECREF(key);

if (lib_obj == NULL) {

PyErr_Clear();

}

if (errstr == NULL)

errstr = ERR_reason_error_string(errcode);

}

if (errstr == NULL)

errstr = "unknown error";

if (reason_obj && lib_obj)

msg = PyUnicode_FromFormat("[%S: %S] %s (_ssl.c:%d)",

lib_obj, reason_obj, errstr, lineno);

else if (lib_obj)

msg = PyUnicode_FromFormat("[%S] %s (_ssl.c:%d)",

lib_obj, errstr, lineno);

else

msg = PyUnicode_FromFormat("%s (_ssl.c:%d)", errstr, lineno);

if (msg == NULL)

goto fail;

init_value = Py_BuildValue("iN", ssl_errno, msg);

err_value = PyObject_CallObject(type, init_value);

Py_DECREF(init_value);

if (err_value == NULL)

goto fail;

if (reason_obj == NULL)

reason_obj = Py_None;

if (_PyObject_SetAttrId(err_value, &PyId_reason, reason_obj))

goto fail;

if (lib_obj == NULL)

lib_obj = Py_None;

if (_PyObject_SetAttrId(err_value, &PyId_library, lib_obj))

goto fail;

PyErr_SetObject(type, err_value);

fail:

Py_XDECREF(err_value);

}

static PyObject *

PySSL_SetError(PySSLSocket *obj, int ret, char *filename, int lineno)

{

PyObject *type = PySSLErrorObject;

char *errstr = NULL;

int err;

enum py_ssl_error p = PY_SSL_ERROR_NONE;

unsigned long e = 0;

assert(ret <= 0);

e = ERR_peek_last_error();

if (obj->ssl != NULL) {

err = SSL_get_error(obj->ssl, ret);

switch (err) {

case SSL_ERROR_ZERO_RETURN:

errstr = "TLS/SSL connection has been closed (EOF)";

type = PySSLZeroReturnErrorObject;

p = PY_SSL_ERROR_ZERO_RETURN;

break;

case SSL_ERROR_WANT_READ:

errstr = "The operation did not complete (read)";

type = PySSLWantReadErrorObject;

p = PY_SSL_ERROR_WANT_READ;

break;

case SSL_ERROR_WANT_WRITE:

p = PY_SSL_ERROR_WANT_WRITE;

type = PySSLWantWriteErrorObject;

errstr = "The operation did not complete (write)";

break;

case SSL_ERROR_WANT_X509_LOOKUP:

p = PY_SSL_ERROR_WANT_X509_LOOKUP;

errstr = "The operation did not complete (X509 lookup)";

break;

case SSL_ERROR_WANT_CONNECT:

p = PY_SSL_ERROR_WANT_CONNECT;

errstr = "The operation did not complete (connect)";

break;

case SSL_ERROR_SYSCALL:

{

if (e == 0) {

PySocketSockObject *s

= (PySocketSockObject *) PyWeakref_GetObject(obj->Socket);

if (ret == 0 || (((PyObject *)s) == Py_None)) {

p = PY_SSL_ERROR_EOF;

type = PySSLEOFErrorObject;

errstr = "EOF occurred in violation of protocol";

} else if (ret == -1) {

/* underlying BIO reported an I/O error */

Py_INCREF(s);

ERR_clear_error();

s->errorhandler();

Py_DECREF(s);

return NULL;

} else { /* possible? */

p = PY_SSL_ERROR_SYSCALL;

type = PySSLSyscallErrorObject;

errstr = "Some I/O error occurred";

}

} else {

p = PY_SSL_ERROR_SYSCALL;

}

break;

}

case SSL_ERROR_SSL:

{

p = PY_SSL_ERROR_SSL;

if (e == 0)

/* possible? */

errstr = "A failure in the SSL library occurred";

break;

}

default:

p = PY_SSL_ERROR_INVALID_ERROR_CODE;

errstr = "Invalid error code";

}

}

fill_and_set_sslerror(type, p, errstr, lineno, e);

ERR_clear_error();

return NULL;

}

static PyObject *

_setSSLError (char *errstr, int errcode, char *filename, int lineno) {

if (errstr == NULL)

errcode = ERR_peek_last_error();

else

errcode = 0;

fill_and_set_sslerror(PySSLErrorObject, errcode, errstr, lineno, errcode);

ERR_clear_error();

return NULL;

}

static PySSLSocket *

newPySSLSocket(SSL_CTX *ctx, PySocketSockObject *sock,

enum py_ssl_server_or_client socket_type,

char *server_hostname)

{

PySSLSocket *self;

self = PyObject_New(PySSLSocket, &PySSLSocket_Type);

if (self == NULL)

return NULL;

self->peer_cert = NULL;

self->ssl = NULL;

self->Socket = NULL;

self->shutdown_seen_zero = 0;

/* Make sure the SSL error state is initialized */

(void) ERR_get_state();

ERR_clear_error();

PySSL_BEGIN_ALLOW_THREADS

self->ssl = SSL_new(ctx);

PySSL_END_ALLOW_THREADS

SSL_set_fd(self->ssl, sock->sock_fd);

#ifdef SSL_MODE_AUTO_RETRY

SSL_set_mode(self->ssl, SSL_MODE_AUTO_RETRY);

#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

if (server_hostname != NULL)

SSL_set_tlsext_host_name(self->ssl, server_hostname);

/* If the socket is in non-blocking mode or timeout mode, set the BIO

if (sock->sock_timeout >= 0.0) {

BIO_set_nbio(SSL_get_rbio(self->ssl), 1);

BIO_set_nbio(SSL_get_wbio(self->ssl), 1);

}

PySSL_BEGIN_ALLOW_THREADS

if (socket_type == PY_SSL_CLIENT)

SSL_set_connect_state(self->ssl);

else

SSL_set_accept_state(self->ssl);

PySSL_END_ALLOW_THREADS

self->socket_type = socket_type;

self->Socket = PyWeakref_NewRef((PyObject *) sock, NULL);

return self;

}

static PyObject *PySSL_SSLdo_handshake(PySSLSocket *self)

{

int ret;

int err;

int sockstate, nonblocking;

PySocketSockObject *sock

= (PySocketSockObject *) PyWeakref_GetObject(self->Socket);

if (((PyObject*)sock) == Py_None) {

_setSSLError("Underlying socket connection gone",

PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__);

return NULL;

}

Py_INCREF(sock);

/* just in case the blocking state of the socket has been changed */

nonblocking = (sock->sock_timeout >= 0.0);

BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);

BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);

/* Actually negotiate SSL connection */

/* XXX If SSL_do_handshake() returns 0, it's also a failure. */

do {

PySSL_BEGIN_ALLOW_THREADS

ret = SSL_do_handshake(self->ssl);

err = SSL_get_error(self->ssl, ret);

PySSL_END_ALLOW_THREADS

if (PyErr_CheckSignals())

goto error;

if (err == SSL_ERROR_WANT_READ) {

sockstate = check_socket_and_wait_for_timeout(sock, 0);

} else if (err == SSL_ERROR_WANT_WRITE) {

sockstate = check_socket_and_wait_for_timeout(sock, 1);

} else {

sockstate = SOCKET_OPERATION_OK;

}

if (sockstate == SOCKET_HAS_TIMED_OUT) {

PyErr_SetString(PySocketModule.timeout_error,

ERRSTR("The handshake operation timed out"));

goto error;

} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {

PyErr_SetString(PySSLErrorObject,

ERRSTR("Underlying socket has been closed."));

goto error;

} else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) {

PyErr_SetString(PySSLErrorObject,

ERRSTR("Underlying socket too large for select()."));

goto error;

} else if (sockstate == SOCKET_IS_NONBLOCKING) {

break;

}

} while (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE);

Py_DECREF(sock);

if (ret < 1)

return PySSL_SetError(self, ret, __FILE__, __LINE__);

if (self->peer_cert)

X509_free (self->peer_cert);

PySSL_BEGIN_ALLOW_THREADS

self->peer_cert = SSL_get_peer_certificate(self->ssl);

PySSL_END_ALLOW_THREADS

Py_INCREF(Py_None);

return Py_None;

error:

Py_DECREF(sock);

return NULL;

}

static PyObject *

_create_tuple_for_attribute (ASN1_OBJECT *name, ASN1_STRING *value) {

char namebuf[X509_NAME_MAXLEN];

int buflen;

PyObject *name_obj;

PyObject *value_obj;

PyObject *attr;

unsigned char *valuebuf = NULL;

buflen = OBJ_obj2txt(namebuf, sizeof(namebuf), name, 0);

if (buflen < 0) {

_setSSLError(NULL, 0, __FILE__, __LINE__);

goto fail;

}

name_obj = PyUnicode_FromStringAndSize(namebuf, buflen);

if (name_obj == NULL)

goto fail;

buflen = ASN1_STRING_to_UTF8(&valuebuf, value);

if (buflen < 0) {

_setSSLError(NULL, 0, __FILE__, __LINE__);

Py_DECREF(name_obj);

goto fail;

}

value_obj = PyUnicode_DecodeUTF8((char *) valuebuf,

buflen, "strict");

OPENSSL_free(valuebuf);

if (value_obj == NULL) {

Py_DECREF(name_obj);

goto fail;

}

attr = PyTuple_New(2);

if (attr == NULL) {

Py_DECREF(name_obj);

Py_DECREF(value_obj);

goto fail;

}

PyTuple_SET_ITEM(attr, 0, name_obj);

PyTuple_SET_ITEM(attr, 1, value_obj);

return attr;

fail:

return NULL;

}

static PyObject *

_create_tuple_for_X509_NAME (X509_NAME *xname)

{

PyObject *dn = NULL; /* tuple which represents the "distinguished name" */

PyObject *rdn = NULL; /* tuple to hold a "relative distinguished name" */

PyObject *rdnt;

PyObject *attr = NULL; /* tuple to hold an attribute */

int entry_count = X509_NAME_entry_count(xname);

X509_NAME_ENTRY *entry;

ASN1_OBJECT *name;

ASN1_STRING *value;

int index_counter;

int rdn_level = -1;

int retcode;

dn = PyList_New(0);

if (dn == NULL)

return NULL;

/* now create another tuple to hold the top-level RDN */

rdn = PyList_New(0);

if (rdn == NULL)

goto fail0;

for (index_counter = 0;

index_counter < entry_count;

index_counter++)

{

entry = X509_NAME_get_entry(xname, index_counter);

/* check to see if we've gotten to a new RDN */

if (rdn_level >= 0) {

if (rdn_level != entry->set) {

/* yes, new RDN */

/* add old RDN to DN */

rdnt = PyList_AsTuple(rdn);

Py_DECREF(rdn);

if (rdnt == NULL)

goto fail0;

retcode = PyList_Append(dn, rdnt);

Py_DECREF(rdnt);

if (retcode < 0)

goto fail0;

/* create new RDN */

rdn = PyList_New(0);

if (rdn == NULL)

goto fail0;

}

}

rdn_level = entry->set;

/* now add this attribute to the current RDN */

name = X509_NAME_ENTRY_get_object(entry);

value = X509_NAME_ENTRY_get_data(entry);

attr = _create_tuple_for_attribute(name, value);

/*

if (attr == NULL)

goto fail1;

retcode = PyList_Append(rdn, attr);

Py_DECREF(attr);

if (retcode < 0)

goto fail1;

}

/* now, there's typically a dangling RDN */

if (rdn != NULL) {

if (PyList_GET_SIZE(rdn) > 0) {

rdnt = PyList_AsTuple(rdn);

Py_DECREF(rdn);

if (rdnt == NULL)

goto fail0;

retcode = PyList_Append(dn, rdnt);

Py_DECREF(rdnt);

if (retcode < 0)

goto fail0;

}

else {

Py_DECREF(rdn);

}

}

/* convert list to tuple */

rdnt = PyList_AsTuple(dn);

Py_DECREF(dn);

if (rdnt == NULL)

return NULL;

return rdnt;

fail1:

Py_XDECREF(rdn);

fail0:

Py_XDECREF(dn);

return NULL;

}

static PyObject *

_get_peer_alt_names (X509 *certificate) {

/* this code follows the procedure outlined in

int i, j;

PyObject *peer_alt_names = Py_None;

PyObject *v = NULL, *t;

X509_EXTENSION *ext = NULL;

GENERAL_NAMES *names = NULL;

GENERAL_NAME *name;

const X509V3_EXT_METHOD *method;

BIO *biobuf = NULL;

char buf[2048];

char *vptr;

int len;

/* Issue #2973: ASN1_item_d2i() API changed in OpenSSL 0.9.6m */

#if OPENSSL_VERSION_NUMBER >= 0x009060dfL

const unsigned char *p;

unsigned char *p;

if (certificate == NULL)

return peer_alt_names;

/* get a memory buffer */

biobuf = BIO_new(BIO_s_mem());

i = -1;

while ((i = X509_get_ext_by_NID(

certificate, NID_subject_alt_name, i)) >= 0) {

if (peer_alt_names == Py_None) {

peer_alt_names = PyList_New(0);

if (peer_alt_names == NULL)

goto fail;

}

/* now decode the altName */

ext = X509_get_ext(certificate, i);

if(!(method = X509V3_EXT_get(ext))) {

PyErr_SetString

(PySSLErrorObject,

ERRSTR("No method for internalizing subjectAltName!"));

goto fail;

}

p = ext->value->data;

if (method->it)

names = (GENERAL_NAMES*)

(ASN1_item_d2i(NULL,

&p,

ext->value->length,

ASN1_ITEM_ptr(method->it)));

else

names = (GENERAL_NAMES*)

(method->d2i(NULL,

&p,

ext->value->length));

for(j = 0; j < sk_GENERAL_NAME_num(names); j++) {

/* get a rendering of each name in the set of names */

int gntype;

ASN1_STRING *as = NULL;

name = sk_GENERAL_NAME_value(names, j);

gntype = name->type;

switch (gntype) {

case GEN_DIRNAME:

/* we special-case DirName as a tuple of

t = PyTuple_New(2);

if (t == NULL) {

goto fail;

}

v = PyUnicode_FromString("DirName");

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 0, v);

v = _create_tuple_for_X509_NAME (name->d.dirn);

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 1, v);

break;

case GEN_EMAIL:

case GEN_DNS:

case GEN_URI:

/* GENERAL_NAME_print() doesn't handle NULL bytes in ASN1_string

t = PyTuple_New(2);

if (t == NULL)

goto fail;

switch (gntype) {

case GEN_EMAIL:

v = PyUnicode_FromString("email");

as = name->d.rfc822Name;

break;

case GEN_DNS:

v = PyUnicode_FromString("DNS");

as = name->d.dNSName;

break;

case GEN_URI:

v = PyUnicode_FromString("URI");

as = name->d.uniformResourceIdentifier;

break;

}

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 0, v);

v = PyUnicode_FromStringAndSize((char *)ASN1_STRING_data(as),

ASN1_STRING_length(as));

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 1, v);

break;

default:

/* for everything else, we use the OpenSSL print form */

switch (gntype) {

/* check for new general name type */

case GEN_OTHERNAME:

case GEN_X400:

case GEN_EDIPARTY:

case GEN_IPADD:

case GEN_RID:

break;

default:

if (PyErr_WarnFormat(PyExc_RuntimeWarning, 1,

"Unknown general name type %d",

gntype) == -1) {

goto fail;

}

break;

}

(void) BIO_reset(biobuf);

GENERAL_NAME_print(biobuf, name);

len = BIO_gets(biobuf, buf, sizeof(buf)-1);

if (len < 0) {

_setSSLError(NULL, 0, __FILE__, __LINE__);

goto fail;

}

vptr = strchr(buf, ':');

if (vptr == NULL)

goto fail;

t = PyTuple_New(2);

if (t == NULL)

goto fail;

v = PyUnicode_FromStringAndSize(buf, (vptr - buf));

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 0, v);

v = PyUnicode_FromStringAndSize((vptr + 1),

(len - (vptr - buf + 1)));

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 1, v);

break;

}

/* and add that rendering to the list */

if (PyList_Append(peer_alt_names, t) < 0) {

Py_DECREF(t);

goto fail;

}

Py_DECREF(t);

}

sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);

}

BIO_free(biobuf);

if (peer_alt_names != Py_None) {

v = PyList_AsTuple(peer_alt_names);

Py_DECREF(peer_alt_names);

return v;

} else {

return peer_alt_names;

}

fail:

if (biobuf != NULL)

BIO_free(biobuf);

if (peer_alt_names != Py_None) {

Py_XDECREF(peer_alt_names);

}

return NULL;

}

static PyObject *

_decode_certificate(X509 *certificate) {

PyObject *retval = NULL;

BIO *biobuf = NULL;

PyObject *peer;

PyObject *peer_alt_names = NULL;

PyObject *issuer;

PyObject *version;

PyObject *sn_obj;

ASN1_INTEGER *serialNumber;

char buf[2048];

int len;

ASN1_TIME *notBefore, *notAfter;

PyObject *pnotBefore, *pnotAfter;

retval = PyDict_New();

if (retval == NULL)

return NULL;

peer = _create_tuple_for_X509_NAME(

X509_get_subject_name(certificate));

if (peer == NULL)

goto fail0;

if (PyDict_SetItemString(retval, (const char *) "subject", peer) < 0) {

Py_DECREF(peer);

goto fail0;

}

Py_DECREF(peer);

issuer = _create_tuple_for_X509_NAME(

X509_get_issuer_name(certificate));

if (issuer == NULL)

goto fail0;

if (PyDict_SetItemString(retval, (const char *)"issuer", issuer) < 0) {

Py_DECREF(issuer);

goto fail0;

}

Py_DECREF(issuer);

version = PyLong_FromLong(X509_get_version(certificate) + 1);

if (version == NULL)

goto fail0;

if (PyDict_SetItemString(retval, "version", version) < 0) {

Py_DECREF(version);

goto fail0;

}

Py_DECREF(version);

/* get a memory buffer */

biobuf = BIO_new(BIO_s_mem());

(void) BIO_reset(biobuf);

serialNumber = X509_get_serialNumber(certificate);

/* should not exceed 20 octets, 160 bits, so buf is big enough */

i2a_ASN1_INTEGER(biobuf, serialNumber);

len = BIO_gets(biobuf, buf, sizeof(buf)-1);

if (len < 0) {

_setSSLError(NULL, 0, __FILE__, __LINE__);

goto fail1;

}

sn_obj = PyUnicode_FromStringAndSize(buf, len);

if (sn_obj == NULL)

goto fail1;

if (PyDict_SetItemString(retval, "serialNumber", sn_obj) < 0) {

Py_DECREF(sn_obj);

goto fail1;

}

Py_DECREF(sn_obj);

(void) BIO_reset(biobuf);

notBefore = X509_get_notBefore(certificate);

ASN1_TIME_print(biobuf, notBefore);

len = BIO_gets(biobuf, buf, sizeof(buf)-1);

if (len < 0) {

_setSSLError(NULL, 0, __FILE__, __LINE__);

goto fail1;

}

pnotBefore = PyUnicode_FromStringAndSize(buf, len);

if (pnotBefore == NULL)

goto fail1;