AsyncSecureSocketClient.h

Go to the documentation of this file.

/*  SecureSocketClient.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_AsyncSecureSocketClient_h
#define OW32_AsyncSecureSocketClient_h

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

// Open Win32 namespace
namespace OW32
{

template <class T>
class CAsyncSecureSocketClient : public CAsyncSecureSocket<T>
{
private:
    CAsyncSecureSocketClient(const CAsyncSecureSocketClient& );
    CAsyncSecureSocketClient& operator=(const CAsyncSecureSocketClient& );

protected:

public:
    CAsyncSecureSocketClient(CAsyncSocketCallback* pCallback) :
        CAsyncSecureSocket<T>(pCallback),
        m_fDoRead(false)
    {
        m_szServerName[0] = _T('\0');
    }

    CAsyncSecureSocketClient(CAsyncSocketCallback* pCallback, SOCKET s) :
        CAsyncSecureSocket<T>(pCallback,s),
        m_fDoRead(false)
    {
        m_szServerName[0] = _T('\0');
    }

    virtual int shutdown(int how);

    void setServerName(LPCTSTR lpszServerName)
    {
        const int nServerBuf = sizeof(m_szServerName)/sizeof(m_szServerName[0]);
        _tcsncpy(m_szServerName, lpszServerName, nServerBuf);
        m_szServerName[nServerBuf-1]=_T('\0');
    }

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

    SECURITY_STATUS createNullCredentials(DWORD dwEnabledProtocols=0);

    static SECURITY_STATUS createCredentialsFromCertificate(
        CredHandle* phCreds, PCCERT_CONTEXT pCertContext, DWORD dwEnabledProtocols=0)
    {
        return CAsyncSecureSocket<T>::createCredentialsFromCertificate(phCreds, pCertContext, 
            SECPKG_CRED_OUTBOUND, dwEnabledProtocols);
    }

protected:
    virtual void negotiateLoop();

private:
    TCHAR m_szServerName[260];
    int disconnectFromServer();
    virtual void onSendCompletion(BOOL bRet, DWORD cbBytesSent);
    virtual void onReadCompletion(BOOL bRet, DWORD cbBytesReceived);
    virtual void onConnectCompletion(BOOL bRet);
    virtual void onTimeout();
    int handshakeSend(const char* data, int length);

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

    bool m_fDoRead;
    SECURITY_STATUS m_scRet;
    SecBuffer m_InBuffers[2];
    SecBufferDesc m_InBuffer;
    SecBuffer m_OutBuffers[1];
    SecBufferDesc m_OutBuffer;

    enum { IO_BUFFER_SIZE = 16*1024 + 5 + 16 };
    auto_array_ptr<char> m_handshakeIo;
    DWORD m_cbHandshakeIo;
};

template <class T>
void CAsyncSecureSocketClient<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 CAsyncSecureSocketClient<T>::onConnectCompletion(BOOL bRet)
{
    if (!bRet) {
        m_pCallback->onConnectCompletion(bRet);
        return;
    }
    (void)negotiate();
}

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

template <class T>
int CAsyncSecureSocketClient<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 = 
        ISC_REQ_SEQUENCE_DETECT   |
        ISC_REQ_REPLAY_DETECT     |
        ISC_REQ_CONFIDENTIALITY   |
        ISC_RET_EXTENDED_ERROR    |
        ISC_REQ_ALLOCATE_MEMORY   |
        ISC_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;
    TimeStamp tsExpiry;
    Status = g_SecurityFunc.InitializeSecurityContext(
                    &m_hCreds,
                    &m_hContext,
                    NULL,
                    dwSSPIFlags,
                    0,
                    SECURITY_NATIVE_DREP,
                    NULL,
                    0,
                    &m_hContext,
                    &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 server.
    //
    m_State = State_Shutdown;
    int ret = handshakeSend((const char *)pbMessage, (int)cbMessage);
    if (ret == SOCKET_ERROR)
        return SOCKET_ERROR;
    return 0;
}

template <class T>
void CAsyncSecureSocketClient<T>::negotiateLoop()
{
    if (m_State == State_Negotiate)
    {
        if (!SecIsValidHandle(&m_hCreds)) {
            if (createNullCredentials() != SEC_E_OK)
            {
                NegotiateError();
                return ;
            }
        }

        DWORD dwSSPIFlags = 
            ISC_REQ_SEQUENCE_DETECT   |
            ISC_REQ_REPLAY_DETECT     |
            ISC_REQ_CONFIDENTIALITY   |
            ISC_RET_EXTENDED_ERROR    |
            ISC_REQ_ALLOCATE_MEMORY   |
            ISC_REQ_STREAM;

        //
        //  Initiate a ClientHello message and generate a token.
        //

        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;
        TimeStamp tsExpiry={0};
        SECURITY_STATUS scRet = g_SecurityFunc.InitializeSecurityContext(
                        &m_hCreds,
                        NULL,
                        m_szServerName,
                        dwSSPIFlags,
                        0,
                        SECURITY_NATIVE_DREP,
                        NULL,
                        0,
                        &m_hContext,
                        &m_OutBuffer,
                        &dwSSPIOutFlags,
                        &tsExpiry);

        if (scRet != SEC_I_CONTINUE_NEEDED)
        {
            SetLastError(scRet);
            NegotiateError();
            return;
        }
    }

    // start by continuing...
    m_scRet = SEC_I_CONTINUE_NEEDED;
    m_fDoRead = m_State==State_Negotiate;
    
    // 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;
    }

    if (m_State==State_Negotiate) {
        // Send response to server if there is one.
        if (m_OutBuffers[0].cbBuffer != 0 && m_OutBuffers[0].pvBuffer != NULL)
        {
            if (handshakeSend((const char *)m_OutBuffers[0].pvBuffer, m_OutBuffers[0].cbBuffer) != 0)
            {
                NegotiateError();
            }
            return;
        }
    }
    ReadCompletion(TRUE, 0);
}

template <class T>
int CAsyncSecureSocketClient<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 CAsyncSecureSocketClient<T>::onSendCompletion(BOOL bRet, DWORD cbSent)
{
    if (m_State == State_Connected)
    {
        CAsyncSecureSocket<T>::onSendCompletion(bRet, cbSent);
        return;
    }
    // Pass on some kind of error or a connection closed 
    // notification  directly 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 CAsyncSecureSocketClient<T>::SendCompletion(BOOL /*bRet*/, DWORD cbSent)
{
    m_sendProcessed += cbSent;

    if (m_sendProcessed < m_sendLength)
    {
        if (T::send(m_sendData + m_sendProcessed, m_sendLength - m_sendProcessed) != 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(SD_SEND) == SOCKET_ERROR)
            NegotiateError();
        break;
    }
}

template <class T>
void CAsyncSecureSocketClient<T>::onReadCompletion(BOOL bRet, DWORD cbReceived)
{
    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 CAsyncSecureSocketClient<T>::ReadCompletion(BOOL /*bRet*/, DWORD cbReceived)
{
    // Set the SSPI flags up
    DWORD dwSSPIFlags = 
        ISC_REQ_SEQUENCE_DETECT   |
        ISC_REQ_REPLAY_DETECT     |
        ISC_REQ_CONFIDENTIALITY   |
        ISC_RET_EXTENDED_ERROR    |
        ISC_REQ_ALLOCATE_MEMORY   |
        ISC_REQ_STREAM;

    m_cbHandshakeIo += cbReceived;

    // 
    // Loop until the handshake is finished or an error occurs.
    //

    while ( m_scRet == SEC_I_CONTINUE_NEEDED        ||
            m_scRet == SEC_E_INCOMPLETE_MESSAGE     ||
            m_scRet == SEC_I_INCOMPLETE_CREDENTIALS) 
    {

        //
        // Read data from server.
        //
        if (0 == m_cbHandshakeIo || m_scRet == SEC_E_INCOMPLETE_MESSAGE)
        {
            if (m_fDoRead) {
                // Too much data; give up
                if (m_cbHandshakeIo >= IO_BUFFER_SIZE) {
                    SetLastError((DWORD)E_UNEXPECTED); // TODO::
                    NegotiateError();
                    return;
                }

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

        //
        // Set up the input buffers. Buffer 0 is used to pass in data
        // received from the server. Schannel will consume some or all
        // of this. Leftover data (if any) will be placed in buffer 1 and
        // given a buffer type of SECBUFFER_EXTRA.
        //
        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;

        //
        // Set up the output buffers. These are initialized to NULL
        // so as to make it less likely we'll attempt to free random
        // garbage later.
        //

        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;

        //
        // Call InitializeSecurityContext.
        //
        DWORD dwSSPIOutFlags = 0;
        TimeStamp tsExpiry = {0};
        
        // 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.InitializeSecurityContext(
                            &m_hCreds,
                            &m_hContext,
                            NULL,
                            dwSSPIFlags,
                            0,
                            SECURITY_NATIVE_DREP,
                            &m_InBuffer,
                            0,
                            &m_hContext,
                            &m_OutBuffer,
                            &dwSSPIOutFlags,
                            &tsExpiry);
        }
        __except(EXCEPTION_EXECUTE_HANDLER)
        {
            m_scRet = GetExceptionCode();
            if (!FAILED(m_scRet)) m_scRet = E_UNEXPECTED;
        }

        //
        // If InitializeSecurityContext was successful (or if the error was 
        // one of the special extended ones), send the contends of the output
        // buffer to the server.
        //

        if(m_scRet == SEC_E_OK                ||
           m_scRet == SEC_I_CONTINUE_NEEDED   ||
           (FAILED(m_scRet) && (dwSSPIOutFlags & ISC_RET_EXTENDED_ERROR)))
        {
            if  (m_OutBuffers[0].cbBuffer != 0    &&
                 m_OutBuffers[0].pvBuffer != NULL )
            {

                //
                // Send response to server if there is one
                //
                if (handshakeSend((const char *)m_OutBuffers[0].pvBuffer, m_OutBuffers[0].cbBuffer) != 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 CAsyncSecureSocketClient<T>::ProcessDecryptedData()
{
    //
    // If InitializeSecurityContext returned SEC_E_INCOMPLETE_MESSAGE,
    // then we need to read more data from the server and try again.
    //

    if ( m_scRet == SEC_E_INCOMPLETE_MESSAGE )
    {
        return true;
    }
    
    // If InitializeSecurityContext returned SEC_E_OK, then the 
    // handshake completed successfully.
    //
    if ( m_scRet == SEC_E_OK )
    {
        // Query the maximum message sizes
        SECURITY_STATUS scRet = querySizes();
        if (scRet != SEC_E_OK)
        {
            SetLastError(scRet);
            NegotiateError();
            return false;
        }
        assert(m_Sizes.cbMaximumMessage != -1 && m_Sizes.cbHeader != -1 &&
            m_Sizes.cbTrailer != -1 && m_Sizes.cbBlockSize != -1 && m_Sizes.cBuffers != -1);

        // 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;
        if (PrevState == State_Negotiate) m_pCallback->onConnectCompletion(TRUE);
        else CAsyncSecureSocket<T>::ReadCompletion(TRUE, 0);
        return false;
    }

    if (FAILED(m_scRet))
    {
        SetLastError(m_scRet);
        NegotiateError();
        return false;
    }

    //
    // If InitializeSecurityContext returned SEC_I_INCOMPLETE_CREDENTIALS,
    // then the server just requested client authentication. 
    //

    if ( m_scRet == SEC_I_INCOMPLETE_CREDENTIALS )
    {
        //
        // Now would be a good time perhaps to prompt the user to select
        // a client certificate and obtain a new credential handle, 
        // but I don't have the energy nor inclination. :-) samples
        //
        // As this is currently written, Schannel will send a "no 
        // certificate" alert to the server in place of a certificate. 
        // The server might be cool with this, or it might drop the 
        // connection.
        // 

        // Go around again.
        m_fDoRead = false;
//      m_cbHandshakeIo = 0;
        m_scRet = SEC_I_CONTINUE_NEEDED;
        return true;
    }


    //
    // Copy any leftover data from the "extra" buffer, and go around
    // again.
    //
    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>
SECURITY_STATUS CAsyncSecureSocketClient<T>::createNullCredentials(
    DWORD dwEnabledProtocols)
{
    freeCredentials();
    SECURITY_STATUS scRet = createCredentialsFromCertificate(&m_hCreds, NULL, dwEnabledProtocols);
    if (SUCCEEDED(scRet))
        m_ownCredentials = true;
    return scRet;
}

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

} // namespace OW32

#endif // OW32_AsyncSecureSocketClient_h

---