KjSslConnection.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "KjSslConnection.h"

KjSslConnection::KjSslConnection(KjSslConnection::EKjSslConType _eType, char* _strConn,const string &_strCertFile, const string &_strKeyFile): m_eType(_eType)
{
        if(!Init(_strCertFile, _strKeyFile))
        {
                m_bIsValid = false;
                return;
        }
    if(m_eType==KJ_SSL_CLIENT)
        {
                m_bIsValid = ClientConnect(_strConn);
        }
    else if (m_eType==KJ_SSL_SERVER)
        {
                m_bIsValid = ServerConnect(_strConn);
        }
}

KjSslConnection::KjSslConnection(BIO* _pBio,const string &_strCertFile, const string &_strKeyFile):
    m_eType(KjSslConnection::KJ_SSL_SERVER),m_pBio(_pBio)
{
        m_iId = -1;
        if(!Init(_strCertFile, _strKeyFile))
        {
                m_bIsValid = false;
                return;
        }
    m_bIsValid = ServerConnect("");
}

KjSslConnection::~KjSslConnection()
{
        SSL_free(m_pSsl);
        m_bIsValid = false;
}

bool KjSslConnection::Init(const string& _strCertFile,  const string& _strKeyFile)
{
        m_pSsl=SSL_new(GetCtx());
    m_bIsValid=(bool)m_pSsl;
    if(!m_bIsValid)
        {
                return false;
        }
    if(!_strCertFile.empty())
        {
                if(SSL_use_certificate_file(m_pSsl,_strCertFile.c_str(),SSL_FILETYPE_PEM)<=0) 
                {
                        CheckErrors("SSL_use_certificate_file");
                        m_bIsValid=false;
                        return false;
                }
        }
    if(!_strKeyFile.empty())
        {
                if(SSL_use_RSAPrivateKey_file(m_pSsl,_strKeyFile.c_str(),SSL_FILETYPE_PEM)<=0) 
                {
                        CheckErrors("SSL_use_RSAPrivateKey_file");
                        m_bIsValid=false;
                        return false;
                }
        }
    if(!_strKeyFile.empty()&&!_strCertFile.empty())
        {
                if(SSL_check_private_key(m_pSsl)<=0) 
                {
                        CheckErrors("SSL_check_private_key");
                        m_bIsValid=false;
                        return false;
                }
        }
    if (SSL_set_cipher_list(m_pSsl,"ALL" )<=0) 
        {
                CheckErrors("SSL_set_cipher_list");
                m_bIsValid=false;
                return false;
    }
        return true;
}

bool KjSslConnection::ServerConnect(char* _strConn)
{
        if(!m_pBio) 
        {
                m_pBio=BIO_new_accept(_strConn);
                if(!m_pBio) 
                {
                        return false;
                }
                BIO_set_bind_mode(m_pBio,BIO_BIND_REUSEADDR);
    }
    SSL_set_bio(m_pSsl, m_pBio, m_pBio);
    SSL_set_accept_state(m_pSsl);
        int iRet = SSL_accept(m_pSsl);
    if(iRet<=0) 
        {
                CheckErrors("SSL_accept");
                CheckSslErrors(m_pSsl, iRet, "SSL_accept");
                return false;
    }
    return true;
}

bool KjSslConnection::ClientConnect(char* _strConn)
{
        m_pBio=BIO_new_connect(_strConn);
    if(BIO_do_connect(m_pBio)<=0) 
        {
                m_bIsValid=false;
                return false;
    }
    SSL_set_bio(m_pSsl,m_pBio,m_pBio);
    SSL_set_connect_state(m_pSsl);
        // SSL client connected
        cout << "SSL client connected..." << endl;
        int iRet = SSL_connect(m_pSsl);
    if(iRet<=0) 
        {
                CheckErrors("SSL_connect");
                CheckSslErrors(m_pSsl, iRet, "SSL_connect");
                return false;
    }
    return true;
}

int KjSslConnection::Write(const string& _str)
{
        int iRet = 0;
        if(CheckSslState())
        {
                int iStrSize = _str.length();
                if(iStrSize > KJ_SSL_READ_CHUNK_SIZE)
                {
                        // Cut message to the more packets
                        string strPacket = _str;
                        for(;;)
                        {
                                if(strPacket.length() <= 0)
                                {
                                        break;
                                }
                                // Get first chunk size characters
                                string strEnd = strPacket;
                                if(strPacket.size() > KJ_SSL_READ_CHUNK_SIZE)
                                {
                                        strEnd.erase(0, KJ_SSL_READ_CHUNK_SIZE);
                                        strPacket.erase(strPacket.begin()+KJ_SSL_READ_CHUNK_SIZE, strPacket.end());
                                }
                                else
                                {
                                        strEnd.erase(0, strPacket.size());
                                }
                                // Write message
                                iRet = SSL_write(m_pSsl,strPacket.c_str(),strPacket.length());
                                strPacket = strEnd;
                        }
                }
                else
                {
                        // Write message
                        iRet = SSL_write(m_pSsl,_str.c_str(),_str.length());
                }
                // Write end message
                string strEnd = KJ_END_MSG;
                iRet = SSL_write(m_pSsl,strEnd.c_str(),strEnd.length());
        }
        else
        {
                cerr << "Error :: int KjSslConnection::Write(const string& _str) -- SSL state is incorrect...!" << endl;
        }
        return iRet;
}

int KjSslConnection::Read(string& _str)
{
        int iRet = 0;
        if(CheckSslState())
        {
                char str[KJ_SSL_READ_CHUNK_SIZE];
                cout << "Waiting for some message ... " << endl;
                iRet = SSL_read(m_pSsl,str, KJ_SSL_READ_CHUNK_SIZE);
                str[iRet]=0;
                _str="";
                _str = str;
        }
        else
        {
                cerr << "Error :: int KjSslConnection::Read(string& _str) -- SSL state is incorrect...!" << endl;
        }
        return iRet;
}

bool KjSslConnection::CheckSslState()
{
        if(SSL_get_state(m_pSsl) != SSL_ST_OK)
        {
                int iRet = SSL_accept(m_pSsl);
                if(iRet <= 0)
                {
                        unsigned long e;
                        char *buf;
                        
                        if((SSL_get_error(m_pSsl, iRet) == SSL_ERROR_WANT_READ) ||
                        SSL_get_error(m_pSsl, iRet) == SSL_ERROR_WANT_WRITE)
                        {
                                cerr << "Error :: bool KjSslConnection::CheckSslState() -- Read blocked, returning" << endl;
                                return false;
                        }
                        e = ERR_get_error();
                        buf = ERR_error_string(e, NULL);
                        cerr << "Error :: bool KjSslConnection::CheckSslState() -- in SSL_accept call " <<  buf << endl;
                        return false;
                }
        }
        return true;
}

---