AsyncSecureSocketServer.h

Go to the documentation of this file.

/*  SecureSocketServer.h - SSL communication through the Schannel API
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_AsyncSecureSocketServer_h
#define OW32_AsyncSecureSocketServer_h

#include <OW32/AsyncSecureSocket.h>
#include <OW32/SSLInit.h>

// Open Win32 namespace
namespace OW32
{

template <class T>
class CAsyncSecureSocketServer : public CAsyncSecureSocket<T>
{
private:
    // Prevent copy, assign
    CAsyncSecureSocketServer& operator= (const CAsyncSecureSocketServer& );
    CAsyncSecureSocketServer(const CAsyncSecureSocketServer& );

public:
    CAsyncSecureSocketServer(CAsyncSocketCallback* pCallback) :
        CAsyncSecureSocket<T>(pCallback)
    {
    }

    CAsyncSecureSocketServer(CAsyncSocketCallback* pCallback, SOCKET s) :
        CAsyncSecureSocket<T>(pCallback, s)
    {
    }

    virtual int shutdown(int how);

    SECURITY_STATUS setServerCertificate(PCCERT_CONTEXT pCertContext,
        DWORD dwEnabledProtocols=0);

    static SECURITY_STATUS createCredentialsFromCertificate(
        CredHandle* phCreds, PCCERT_CONTEXT pCertContext, DWORD dwEnabledProtocols=0)
    {
        return CSecureSocket::createCredentialsFromCertificate(phCreds, pCertContext, 
            SECPKG_CRED_INBOUND, dwEnabledProtocols);
    }

protected:
    virtual void negotiateLoop();

private:
    void NegotiateError();

    void ReadCompletion(BOOL bRet, DWORD cbReceived);
    void SendCompletion(BOOL bRet, DWORD cbSent);

    virtual void onSendCompletion(BOOL bRet, DWORD cbBytesSent);
    virtual void onReadCompletion(BOOL bRet, DWORD cbBytesReceived);
    virtual void onTimeout();

    bool ProcessDecryptedData();
    int handshakeSend(const char* data, int length);

    auto_array_ptr<char> m_handshakeIo;
    DWORD m_cbHandshakeIo;

    SECURITY_STATUS m_scRet;
    SecBuffer m_InBuffers[2];
    SecBufferDesc m_InBuffer;
    SecBuffer m_OutBuffers[1];
    SecBufferDesc m_OutBuffer;
    int m_shutdownHow;

    enum { IO_BUFFER_SIZE = 16*1024 };
};

template <class T>
void CAsyncSecureSocketServer<T>::NegotiateError()
{
    switch (m_State)
    {
    case State_Negotiate:
        m_pCallback->onConnectCompletion(FALSE);
        break;
    case State_Renegotiate: // happening transparently during a read() call
    case State_Connected:
        m_pCallback->onReadCompletion(FALSE,0);
        break;
    case State_Shutdown:
        m_pCallback->onCloseCompletion(FALSE); // TODO: really close?
        break;
    }
}

template <class T>
void CAsyncSecureSocketServer<T>::onTimeout()
{
    if (m_State == State_Connected) {
        m_pCallback->onTimeout();
        return;
    }
    SetLastError(ERROR_TIMEOUT);
    NegotiateError();
}

template <class T>
void CAsyncSecureSocketServer<T>::negotiateLoop()
{
    // start by continuing...
    m_scRet = SEC_I_CONTINUE_NEEDED;
    
    // This is horrible.  Essentially, we don't /know/ how much data schannel
    // wants until it has told us so.  The absolute best we could do is have
    // a loop that goes around & allocates more buffer until we've got enough.
    // However, since we are dealing with SSL/PCT (at present) then we know
    // what the limit is.  So 16K will be enough for a single message.
    // We can't get the maximum message size until the connection is
    // established (sigh).  For the extra data, again, this could return more
    // than a maximum message if we over-read.  To cope with this, we /will/
    // allocate more extra buffer space than that; and never free it.  Not
    // really a possible case, but it will work in spite of it.
    // If only there was more information!
    m_handshakeIo.reset(new char[IO_BUFFER_SIZE]);
    m_cbHandshakeIo = 0;

    // If we have extra data, assume this is from a previous read
    // and use it
    if (m_ExtraCount > 0) 
    {
        // Too much extra data?  Oops, we're stuffed now!
        if (m_ExtraCount > IO_BUFFER_SIZE) 
        {
            SetLastError((DWORD)E_UNEXPECTED);
            NegotiateError();
            return;
        }
        CopyMemory(m_handshakeIo.get(), m_Extra.get(), m_ExtraCount);
        m_cbHandshakeIo = m_ExtraCount;
    }
    ReadCompletion(TRUE,0);
}

template <class T>
int CAsyncSecureSocketServer<T>::handshakeSend(const char* data, int length)
{
    m_sendData = data;
    m_sendLength = length;
    m_sendProcessed = 0;
    return T::send(data, length);
}

template <class T>
void CAsyncSecureSocketServer<T>::onSendCompletion(BOOL bRet, DWORD cbSent)
{
    if (m_State == State_Initial)
    {
        m_pCallback->onSendCompletion(bRet, cbSent);
        return;
    }

    if (m_State == State_Connected)
    {
        CAsyncSecureSocket<T>::onSendCompletion(bRet, cbSent);
        return;
    }

    // Pass on some kind of error or a connection closed 
    // notification directly on to our client
    if (!bRet || cbSent == 0) {
        if (cbSent == 0 && bRet) // TODO: hmmm
            SetLastError(ERROR_INVALID_FUNCTION);
        NegotiateError();
        return;
    }
    SendCompletion(bRet, cbSent);
}

template <class T>
void CAsyncSecureSocketServer<T>::SendCompletion(BOOL bRet, DWORD cbSent)
{
    bRet;
    m_sendProcessed += cbSent;

    if (m_sendProcessed < m_sendLength)
    {
        int ret = T::send(m_sendData + m_sendProcessed, m_sendLength - m_sendProcessed);
        if (ret != 0)
        {
            NegotiateError();
        }
        return;
    }

    if (m_sendData)
        g_SecurityFunc.FreeContextBuffer( (PVOID)m_sendData );
    m_sendData = NULL;

    switch (m_State)
    {
    case State_Negotiate:
    case State_Renegotiate:
        if (ProcessDecryptedData())
            ReadCompletion(TRUE, 0);
        break;
    case State_Shutdown:
        // The next thing to do is to actually call shutdown to close the socket
        if (CAsyncSecureSocket<T>::shutdown(m_shutdownHow) == SOCKET_ERROR)
            NegotiateError();
        break;
    }
}

template <class T>
void CAsyncSecureSocketServer<T>::onReadCompletion(BOOL bRet, DWORD cbReceived)
{
    if (m_State == State_Initial)
    {
        m_pCallback->onReadCompletion(bRet, cbReceived);
        return;
    }

    if (m_State == State_Connected)
    {
        CAsyncSecureSocket<T>::onReadCompletion(bRet, cbReceived);
        return;
    }

    // Pass on some kind of error or a connection closed 
    // notification  directly to our client
    if (!bRet || cbReceived == 0) {
        if (cbReceived == 0 && bRet) // TODO: hmmm
            SetLastError(ERROR_INVALID_FUNCTION);
        NegotiateError();
        return;
    }
    ReadCompletion(bRet, cbReceived);
}

template <class T>
void CAsyncSecureSocketServer<T>::ReadCompletion(BOOL bRet, DWORD cbReceived)
{
    bRet;
    m_cbHandshakeIo += cbReceived;

    while ( m_scRet == SEC_I_CONTINUE_NEEDED        ||
            m_scRet == SEC_E_INCOMPLETE_MESSAGE     ||
            m_scRet == SEC_I_INCOMPLETE_CREDENTIALS) 
    {
        // Read data if required
        if (0 == m_cbHandshakeIo || m_scRet == SEC_E_INCOMPLETE_MESSAGE)
        {
            // Too much data; give up
            if (m_cbHandshakeIo >= IO_BUFFER_SIZE) {
                SetLastError((DWORD)E_UNEXPECTED);
                NegotiateError();
                return;
            }

            // So on re-entry we don't still have SEC_E_INCOMPLETE_MESSAGE
            // and read again!
            m_scRet = SEC_I_CONTINUE_NEEDED;
            int ret = T::recv(&m_handshakeIo[m_cbHandshakeIo], IO_BUFFER_SIZE-m_cbHandshakeIo);
            if (ret != 0)
                NegotiateError();
            return;
        }

        //
        // InBuffers[1] is for getting extra data that
        //  SSPI/SCHANNEL doesn't proccess on this
        //  run around the loop.
        //
        m_InBuffers[0].pvBuffer = m_handshakeIo.get();
        m_InBuffers[0].cbBuffer = m_cbHandshakeIo ;
        m_InBuffers[0].BufferType = SECBUFFER_TOKEN;

        m_InBuffers[1].pvBuffer   = NULL;
        m_InBuffers[1].cbBuffer   = 0;
        m_InBuffers[1].BufferType = SECBUFFER_EMPTY;

        m_InBuffer.cBuffers        = 2;
        m_InBuffer.pBuffers        = m_InBuffers;
        m_InBuffer.ulVersion       = SECBUFFER_VERSION;

        //
        // Initialize these so if we fail, pvBuffer contains NULL,
        // so we don't try to free random garbage at the quit
        //

        //
        //  set OutBuffer for InitializeSecurityContext call
        //
        m_OutBuffer.cBuffers        = 1;
        m_OutBuffer.pBuffers        = m_OutBuffers;
        m_OutBuffer.ulVersion       = SECBUFFER_VERSION;

        m_OutBuffers[0].pvBuffer    = NULL;
        m_OutBuffers[0].BufferType  = SECBUFFER_TOKEN;
        m_OutBuffers[0].cbBuffer    = 0;

        DWORD dwSSPIOutFlags = 0;
        DWORD dwSSPIFlags =   
                ASC_REQ_SEQUENCE_DETECT |
                ASC_REQ_REPLAY_DETECT   |
                ASC_REQ_CONFIDENTIALITY |
                ASC_REQ_EXTENDED_ERROR  |
                ASC_REQ_ALLOCATE_MEMORY |
                ASC_REQ_STREAM |
                (m_bRequireClientAuth ? ASC_REQ_MUTUAL_AUTH : 0);
        TimeStamp tsExpiry = {0};

        // Initial context if we don't already have one...
        bool fInitContext = !SecIsValidHandle(&m_hContext);

        // This is in here because it fucks up on Windows NT if
        // you feed it rubbish data (for example, via telnet).  Marvellous.
        __try 
        {
            m_scRet = g_SecurityFunc.AcceptSecurityContext(
                            &m_hCreds,
                            (fInitContext?NULL:&m_hContext),
                            &m_InBuffer,
                            dwSSPIFlags,
                            SECURITY_NATIVE_DREP,
                            (fInitContext?&m_hContext:NULL),
                            &m_OutBuffer,
                            &dwSSPIOutFlags,
                            &tsExpiry);
        } 
        __except(EXCEPTION_EXECUTE_HANDLER)
        {
            m_scRet = GetExceptionCode();
            if (!FAILED(m_scRet)) m_scRet = E_UNEXPECTED;
        }

        // Send some data if we have it
        if ( m_scRet == SEC_E_OK ||
             m_scRet == SEC_I_CONTINUE_NEEDED ||
             (FAILED(m_scRet) && (0 != (dwSSPIOutFlags & ASC_RET_EXTENDED_ERROR))))
        {
            if  (m_OutBuffers[0].cbBuffer != 0    &&
                 m_OutBuffers[0].pvBuffer != NULL )
            {

                //
                // Send response to server if there is one
                //
                int ret = handshakeSend((const char *)m_OutBuffers[0].pvBuffer, m_OutBuffers[0].cbBuffer);
                if (ret != 0)
                {
                    NegotiateError();
                }
                return;
            }
        } else if (m_OutBuffers[0].pvBuffer != NULL) {
            // Basically, we shouldn't have an output buffer here unless SCHANNEL
            // has indicated that it has returned one.  Oh well, free it anyway;
            // just to be sure.
            g_SecurityFunc.FreeContextBuffer( m_OutBuffers[0].pvBuffer );
            m_OutBuffers[0].pvBuffer = NULL;
        }

        ProcessDecryptedData();
    }
}

template <class T>
bool CAsyncSecureSocketServer<T>::ProcessDecryptedData()
{
    // whoopy!
    if ( m_scRet == SEC_E_OK )
    {
        // Query the maximum message sizes
        SECURITY_STATUS m_scRet = querySizes();
        if (m_scRet != SEC_E_OK)
        {
            SetLastError(m_scRet);
            NegotiateError();
            return false;
        }
        
        // Delete the old extra data buffer if we created one
        // size may have changed?
        m_Extra.reset(0);

        // work out how much space to allocate for a new one.  Note - we 
        // will not allocate an extra buffer unless necessary.
        DWORD dwExtraSize = m_Sizes.cbMaximumMessage+m_Sizes.cbHeader+m_Sizes.cbTrailer;
        if ( m_InBuffers[1].BufferType == SECBUFFER_EXTRA )
        {
            // If not enough space by default, allocate some more...
            if (dwExtraSize < m_InBuffers[1].cbBuffer)
                dwExtraSize = m_InBuffers[1].cbBuffer;

            m_ExtraCount = m_InBuffers[1].cbBuffer;
            m_Extra.reset(new char[dwExtraSize]);
            CopyMemory(m_Extra.get(), (LPBYTE) (m_handshakeIo.get() + 
                (m_cbHandshakeIo - m_InBuffers[1].cbBuffer)), m_ExtraCount);
        }

        // all done
        ConnectionState PrevState = m_State;
        m_State = State_Connected;
        switch (PrevState)
        {
        case State_Negotiate:
            m_pCallback->onConnectCompletion(TRUE);
            break;
        case State_Renegotiate:
            ReadCompletion(TRUE, 0);
            break;
        }
        return false;
    }

    if (FAILED(m_scRet) && (m_scRet != SEC_E_INCOMPLETE_MESSAGE))
    {
        // pants, it went wrong
        SetLastError(m_scRet);
        NegotiateError();
        return false;
    }

    // If we've potentially got extra data, then process it by copying it
    // to our SCHANNEL input buffer
    if ( m_scRet != SEC_E_INCOMPLETE_MESSAGE &&
         m_scRet != SEC_I_INCOMPLETE_CREDENTIALS)
    {

        if ( m_InBuffers[1].BufferType == SECBUFFER_EXTRA )
        {
            // No need to check the amount of data here as we are already
            // fetching it from the input buffer space...
            MoveMemory(m_handshakeIo.get(),
                   (LPBYTE) (m_handshakeIo.get() + (m_cbHandshakeIo - m_InBuffers[1].cbBuffer)),
                    m_InBuffers[1].cbBuffer);
            m_cbHandshakeIo = m_InBuffers[1].cbBuffer;
        }
        else
        {
            //
            // prepare for next receive
            //
            m_cbHandshakeIo = 0;
        }
    }
    return true;
}

template <class T>
int CAsyncSecureSocketServer<T>::shutdown(int how)
{
    if (m_State != State_Connected) {
        return  CAsyncSecureSocket<T>::shutdown(how);
    }

    //
    // Notify schannel that we are about to close the connection.
    //

    DWORD dwType = SCHANNEL_SHUTDOWN;

    SecBuffer OutBuffers[1];
    OutBuffers[0].pvBuffer   = &dwType;
    OutBuffers[0].BufferType = SECBUFFER_TOKEN;
    OutBuffers[0].cbBuffer   = sizeof(dwType);

    SecBufferDesc OutBuffer;
    OutBuffer.cBuffers  = 1;
    OutBuffer.pBuffers  = OutBuffers;
    OutBuffer.ulVersion = SECBUFFER_VERSION;

    SECURITY_STATUS Status = g_SecurityFunc.ApplyControlToken(&m_hContext, &OutBuffer);

    if (FAILED(Status))
    {
        SetLastError(Status);
        return SOCKET_ERROR;
    }

    //
    // Build an SSL close notify message.
    //

    DWORD dwSSPIFlags =   
        ASC_REQ_SEQUENCE_DETECT |
        ASC_REQ_REPLAY_DETECT   |
        ASC_REQ_CONFIDENTIALITY |
        ASC_REQ_EXTENDED_ERROR  |
        ASC_REQ_ALLOCATE_MEMORY |
        ASC_REQ_STREAM;

    OutBuffers[0].pvBuffer   = NULL;
    OutBuffers[0].BufferType = SECBUFFER_TOKEN;
    OutBuffers[0].cbBuffer   = 0;

    OutBuffer.cBuffers  = 1;
    OutBuffer.pBuffers  = OutBuffers;
    OutBuffer.ulVersion = SECBUFFER_VERSION;

    DWORD dwSSPIOutFlags = 0;
    TimeStamp tsExpiry = {0};
    Status = g_SecurityFunc.AcceptSecurityContext(
                    &m_hCreds,
                    &m_hContext,
                    NULL,
                    dwSSPIFlags,
                    SECURITY_NATIVE_DREP,
                    NULL,
                    &OutBuffer,
                    &dwSSPIOutFlags,
                    &tsExpiry);

    if (FAILED(Status))
    {
        SetLastError(Status);
        return SOCKET_ERROR;
    }

    PBYTE pbMessage = (unsigned char *)OutBuffers[0].pvBuffer;
    DWORD cbMessage = OutBuffers[0].cbBuffer;

    //
    // Send the close notify message to the client.
    //

    // Nothing to send?
    if (pbMessage == NULL || cbMessage == 0)
    {
        return CAsyncSecureSocket<T>::shutdown(how);
    }

    // Send the data
    m_State = State_Shutdown;
    m_shutdownHow = how;
    if (handshakeSend((const char*)pbMessage, (int)cbMessage) != 0)
    {
        return SOCKET_ERROR;
    }
    return 0;
}

template <class T>
SECURITY_STATUS CAsyncSecureSocketServer<T>::setServerCertificate(PCCERT_CONTEXT pCertContext,
    DWORD dwEnabledProtocols)
{
    SECURITY_STATUS scRet = createCredentialsFromCertificate(&m_hCreds, pCertContext, 
        dwEnabledProtocols);
    if (SUCCEEDED(scRet)) 
        m_ownCredentials = true;
    return scRet;
}

} // namespace OW32

#endif // OW32_AsyncSecureSocketServer_h

---