windows-server-2003/termsrv/common/license/hclient/liclient/cliprot.c

/*++

Copyright (c) 1998-99  Microsoft Corporation

Module Name:

    cliprot.c

Abstract:

Author:

    Frederick Chong (fredch) 6/1/1998

Environment:

    Win32, WinCE, Win16

Notes:

--*/

#include "windows.h"
#ifndef OS_WINCE
#include "stdio.h"
#endif // OS_WINCE
#include "stdlib.h"

#ifdef OS_WINCE
#include "wincelic.h"
#endif  //OS_WINCE

#include "tchar.h"

#include "lmcons.h"

#include "seccom.h"

#include "cryptkey.h"
#include "hccontxt.h"
#include "cliprot.h"
#include "hcpack.h"
#include "store.h"
#include "licdbg.h"
#include "platform.h"
#include "licecert.h"

#ifdef _WIN64

#define OFFSET_OF(type, field)    ((LONG)(LONG_PTR)&(((type *)0)->field))

#else

#define OFFSET_OF(type, field)    ((LONG)(LONG *)&(((type *)0)->field))

#endif

#define MAX_ALLOWABLE_LICENSE_SIZE (256 * 1024)
#define EXTENDED_ERROR_CAPABILITY 0x80


VOID
FreeProprietaryCertificate(
    PHydra_Server_Cert * ppCertificate );

static BOOL GeneratePseudoLicense(DWORD FAR * pcbData , PBYTE *ppbData);

static LICENSE_STATUS MapStoreError(LS_STATUS lsStatus)
{
    if(lsStatus == LSSTAT_SUCCESS)
        return LICENSE_STATUS_OK;
    if( (lsStatus == LSSTAT_ERROR) || (lsStatus == LSSTAT_INVALID_HANDLE) )
        return LICENSE_STATUS_INVALID_INPUT;
    if(lsStatus == LSSTAT_INSUFFICIENT_BUFFER)
        return LICENSE_STATUS_INSUFFICIENT_BUFFER;
    if(lsStatus == LSSTAT_LICENSE_NOT_FOUND)
        return LICENSE_STATUS_NO_LICENSE_ERROR;
    if(lsStatus == LSSTAT_OUT_OF_MEMORY)
        return LICENSE_STATUS_OUT_OF_MEMORY;
    if(lsStatus == LSSTAT_LICENSE_EXISTS)
        return LICENSE_STATUS_DUPLICATE_LICENSE_ERROR;

    return LICENSE_STATUS_INVALID_INPUT;
}


LICENSE_STATUS
CALL_TYPE
LicenseClientHandleServerMessage(
                     PLicense_Client_Context    pContext,
                     UINT32                     *puiExtendedErrorInfo,
                     BYTE FAR *                 pbInput,
                     DWORD                      cbInput,
                     BYTE FAR *                 pbOutput,
                     DWORD FAR *                pcbOutput
                     )
{
    LICENSE_STATUS      lsReturn = LICENSE_STATUS_OK;
    BYTE FAR            *pbTemp = NULL;
    DWORD               dwTemp = 0;
    Preamble            Header;
    BOOL                fNew = FALSE;
    BOOL                fSupportExtendedError = FALSE;

    if(NULL == pContext || NULL == pbInput || pcbOutput == NULL)
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    pbTemp = pbInput;
    dwTemp = cbInput;
    
    Header = *( UNALIGNED Preamble*)pbTemp;

    //
    // check if we can support this preamble version
    //

    if( Header.bVersion > LICENSE_CURRENT_PREAMBLE_VERSION )
    {
        lsReturn = LICENSE_STATUS_NOT_SUPPORTED;
        goto CommonReturn;
    }

    //
    // Sets the preamble version to the version that the server is using
    //

   
    pContext->dwProtocolVersion |= Header.bVersion;

    if(pContext->dwProtocolVersion >= 2)
    {
        fSupportExtendedError = TRUE;
    }

    if( Header.wMsgSize != dwTemp)
    {
        License_Error_Message Error;
        memset(&Error, 0x00, sizeof(License_Error_Message));
        Error.dwErrorCode = GM_HS_ERR_INVALID_MESSAGE_LEN;
        Error.dwStateTransition = ST_RESEND_LAST_MESSAGE;
        Error.bbErrorInfo.wBlobType = BB_ERROR_BLOB;
        Error.bbErrorInfo.wBlobLen = 0;
        Error.bbErrorInfo.pBlob = NULL;
        
        DebugLog((DEB_TRACE, "Packing License Error Message from Client : %4d\n", *pcbOutput));
        PackLicenseErrorMessage(&Error, fSupportExtendedError, pbOutput, pcbOutput);
        
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        goto CommonReturn;
    }

    pbTemp += sizeof(Preamble);
    dwTemp -= sizeof(Preamble);

    switch(Header.bMsgType)
    {
    case GM_ERROR_ALERT:
        {
            License_Error_Message   Error;
            
            memset(&Error, 0x00, sizeof(License_Error_Message));
            
            DebugLog((DEB_TRACE, "Unpacking Hydra Server Error Message of size: %4d\n", dwTemp));
            if( LICENSE_STATUS_OK != (lsReturn = UnPackLicenseErrorMessage(pbTemp, 
                                                                           dwTemp,
                                                                           &Error)) )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }

            DebugLog((DEB_TRACE, "LicenseClientHandleServerError : %4d\n", *pcbOutput));
            lsReturn = LicenseClientHandleServerError(pContext, 
                                                      &Error,
                                                      puiExtendedErrorInfo,
                                                      pbOutput, 
                                                      pcbOutput);
            if(Error.bbErrorInfo.pBlob) 
            {
                free(Error.bbErrorInfo.pBlob);
                Error.bbErrorInfo.pBlob = NULL;
            }
#if DBG
            if(pbOutput)
                OutputDebugString(_T("Client response data : \n"));
            LS_DUMPSTRING(*pcbOutput, pbOutput);
#endif
                
            if( lsReturn == LICENSE_STATUS_OK ||
                lsReturn == LICENSE_STATUS_CONTINUE ||
                lsReturn == LICENSE_STATUS_CLIENT_ABORT ||
                lsReturn == LICENSE_STATUS_SERVER_ABORT )
                goto CommonReturn;
            else
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }

            break;
        }
    case HS_LICENSE_REQUEST:
        {
            Hydra_Server_License_Request    LicRequest;
            DWORD                           dw;

            memset(&LicRequest, 0x00, sizeof(Hydra_Server_License_Request));
            
            DebugLog((DEB_TRACE, "Unpacking Hydra Server's License Request : %4d\n", dwTemp));
            if( LICENSE_STATUS_OK != (lsReturn = UnpackHydraServerLicenseRequest(pbTemp, 
                                                                                 dwTemp, 
                                                                                 &LicRequest)) )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            
            DebugLog((DEB_TRACE, "Client handles Server's license Request : %4d\n", *pcbOutput));
            
            lsReturn = LicenseClientHandleServerRequest(pContext, 
                                                        &LicRequest, 
                                                        TRUE, 
                                                        pbOutput, 
                                                        pcbOutput,
                                                        fSupportExtendedError);
#if DBG
            if(pbOutput)
                OutputDebugString(_T("Client response data : \n"));
            LS_DUMPSTRING(*pcbOutput, pbOutput);
#endif

            if(LicRequest.ProductInfo.pbCompanyName)
            {
                free(LicRequest.ProductInfo.pbCompanyName);
                LicRequest.ProductInfo.pbCompanyName = NULL;
            }
            if(LicRequest.ProductInfo.pbProductID)
            {
                free(LicRequest.ProductInfo.pbProductID);
                LicRequest.ProductInfo.pbProductID = NULL;
            }

            for(dw = 0; dw <LicRequest.ScopeList.dwScopeCount; dw++)
            {
                if(LicRequest.ScopeList.Scopes[dw].pBlob)
                {
                    free(LicRequest.ScopeList.Scopes[dw].pBlob);
                    LicRequest.ScopeList.Scopes[dw].pBlob = NULL;
                }
            }

            if(LicRequest.ScopeList.Scopes)
            {
                free(LicRequest.ScopeList.Scopes);
                LicRequest.ScopeList.Scopes = NULL;
            }

            if( LicRequest.KeyExchngList.pBlob )
            {
                free( LicRequest.KeyExchngList.pBlob );
            }

            if( LicRequest.ServerCert.pBlob )
            {
                free( LicRequest.ServerCert.pBlob );
            }

            if( lsReturn != LICENSE_STATUS_OK &&
                lsReturn != LICENSE_STATUS_CONTINUE &&
                lsReturn != LICENSE_STATUS_CLIENT_ABORT )
            {

                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            break;
        }
    case HS_PLATFORM_CHALLENGE:
        {
            Hydra_Server_Platform_Challenge     PlatformCh;
            memset(&PlatformCh, 0x00, sizeof(Hydra_Server_Platform_Challenge));
            
            DebugLog((DEB_TRACE, "Unpacking Hydra Server's platform Challenge Request : %4d\n", dwTemp));
            if( LICENSE_STATUS_OK != (lsReturn = UnPackHydraServerPlatformChallenge(pbTemp, 
                                                                                    dwTemp, 
                                                                                    &PlatformCh)) )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            
            DebugLog((DEB_TRACE, "Client Handles Server's platform Challenge Response : %0d\n", *pcbOutput));
            lsReturn = LicenseClientHandleServerPlatformChallenge(pContext, 
                                                                 &PlatformCh, 
                                                                 pbOutput, 
                                                                 pcbOutput,
                                                                 fSupportExtendedError);
#if DBG
            if(pbOutput)
                OutputDebugString(_T("Client response data : \n"));
            LS_DUMPSTRING(*pcbOutput, pbOutput);
#endif

            if(PlatformCh.EncryptedPlatformChallenge.pBlob)
            {
                free(PlatformCh.EncryptedPlatformChallenge.pBlob);
                PlatformCh.EncryptedPlatformChallenge.pBlob = NULL;
            }
                
            if( lsReturn!=LICENSE_STATUS_CONTINUE )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            break;
        }
       
    case HS_NEW_LICENSE: 
            fNew = TRUE;
            DebugLog((DEB_TRACE, "New License received from Server.\n"));
    case HS_UPGRADE_LICENSE:
        {
            Hydra_Server_New_License    NewLicense;

            if (dwTemp > MAX_ALLOWABLE_LICENSE_SIZE)
            {
                //
                // SECURITY: Too much data to store in the registry
                // Reject the message
                //

                LS_LOG_RESULT(lsReturn = LICENSE_STATUS_INVALID_INPUT);
                goto ErrorReturn;
            }

            memset(&NewLicense, 0x00, sizeof(Hydra_Server_New_License));


            DebugLog((DEB_TRACE, "Unpacking Hydra Server's New License Message : %4d\n", dwTemp));

            if(LICENSE_STATUS_OK !=
                (lsReturn = UnPackHydraServerNewLicense(pbTemp, 
                                                        dwTemp, 
                                                        &NewLicense)) )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }

            DebugLog((DEB_TRACE, "License Client handles New License : %4d\n", *pcbOutput));
            lsReturn = LicenseClientHandleNewLicense(pContext, 
                                                     &NewLicense,
                                                     fNew,
                                                     pbOutput, 
                                                     pcbOutput);


            if(NewLicense.EncryptedNewLicenseInfo.pBlob)
            {
                free(NewLicense.EncryptedNewLicenseInfo.pBlob);
                NewLicense.EncryptedNewLicenseInfo.pBlob = NULL;
            }

#if DBG
            if(pbOutput)
                OutputDebugString(_T("Client response data : \n"));
            LS_DUMPSTRING(*pcbOutput, pbOutput);
#endif

            if( lsReturn != LICENSE_STATUS_OK )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            break;
        }
    default:
        //
        // Invalid message type
        //

        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        goto ErrorReturn;
        break;
    }
    LS_LOG_RESULT(lsReturn);

CommonReturn:
    
    return lsReturn;
    LS_RETURN(lsReturn);

ErrorReturn:
    *pcbOutput = 0;

    goto CommonReturn;
}

LICENSE_STATUS
CALL_TYPE
LicenseClientHandleServerError(
                               PLicense_Client_Context  pContext,
                               PLicense_Error_Message   pCanonical,
                               UINT32                   *puiExtendedErrorInfo,
                               BYTE FAR *               pbMessage,
                               DWORD FAR *              pcbMessage
                               )
{
    LICENSE_STATUS      lsReturn = LICENSE_STATUS_OK;
    LS_BEGIN(TEXT("LicenseClientHandleServerError"));

    if(NULL == pContext || NULL == pCanonical || NULL == pcbMessage || NULL == puiExtendedErrorInfo)
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        return lsReturn;        
    }
    
    // Switch on the StateTransition as this dictates the next state
    // client has to take!

    switch(pCanonical->dwStateTransition)
    {
    
    case ST_TOTAL_ABORT: //Server has asked for a total abort
        *pcbMessage = 0;
        if( pCanonical->dwErrorCode == GM_HS_ERR_INVALID_CLIENT ||
            pCanonical->dwErrorCode == GM_HS_ERR_INVALID_SCOPE  ||
            pCanonical->dwErrorCode == GM_HS_ERR_INVALID_PRODUCTID ||
            pCanonical->dwErrorCode == GM_HS_ERR_INVALID_CLIENT )
        {
            lsReturn = LICENSE_STATUS_SERVER_ABORT;
        }
        else
            lsReturn = LICENSE_STATUS_CLIENT_ABORT;

        pContext->dwState = LICENSE_CLIENT_STATE_ABORT;
        pContext->cbLastMessage = 0;
        break;
    
    case ST_NO_TRANSITION:
        lsReturn = LICENSE_STATUS_OK;
        *pcbMessage = 0;
        break;
    
    case ST_RESEND_LAST_MESSAGE:
        // Server has asked to send the last send message again!
        // treat as error (fall through)

    case ST_RESET_PHASE_TO_START:
        // Server has asked to restart the negotiation
        // treat as error (fall through)

    default:
        // Server sent unknown dwStateTransition

        lsReturn = LICENSE_STATUS_CLIENT_ABORT;
        pContext->dwState = LICENSE_CLIENT_STATE_ABORT;
        pContext->cbLastMessage = 0;
        break;

    }

    if ((lsReturn != LICENSE_STATUS_OK) && (pCanonical->bbErrorInfo.wBlobLen > 0) && (pCanonical->bbErrorInfo.pBlob != NULL))
    {
        // ignore any errors

        UnPackExtendedErrorInfo(puiExtendedErrorInfo,&(pCanonical->bbErrorInfo));
    }

    LS_LOG_RESULT(lsReturn);
    return lsReturn;
}

LICENSE_STATUS
CALL_TYPE
LicenseClientHandleServerRequest(
                               PLicense_Client_Context          pContext,
                               PHydra_Server_License_Request    pCanonical,
                               BOOL                             fNewLicense,
                               BYTE FAR *                       pbMessage,
                               DWORD FAR *                      pcbMessage,
                               BOOL                             fExtendedError
                               )
{
    LICENSE_STATUS      lsReturn = LICENSE_STATUS_OK;
    UCHAR               Random[LICENSE_RANDOM];
    UCHAR               PreMasterSecret[LICENSE_PRE_MASTER_SECRET];
    HANDLE      hStore = NULL;
    LSINDEX     lsIndex;
    DWORD       dwCount = 0;
    BYTE FAR *      pbData = NULL;
    DWORD       cbData = 0;

    LS_BEGIN(TEXT("LicenseClientHandleServerRequest"));

    memset(&lsIndex, 0x00, sizeof(LSINDEX));


    if( (pContext == NULL) || (pCanonical == NULL)  )
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    if(pContext->dwState != LICENSE_CLIENT_STATE_WAIT_SERVER_HELLO)
    {
        lsReturn = LICENSE_STATUS_INVALID_CLIENT_STATE;
        goto ErrorReturn;
    }

    if( pContext->dwContextFlags & LICENSE_CONTEXT_NO_SERVER_AUTHENTICATION )
    {
        //
        // No server authentication required, make sure that we have the
        // public key or the certificate of the server so that we can use it to 
        // encrypt the pre-master secret during the next phase of the licensing protocol.
        // 
    
        if( ( NULL == pContext->pbServerPubKey ) && ( NULL == pContext->pServerCert ) )
        {
            lsReturn = LICENSE_STATUS_CONTEXT_INITIALIZATION_ERROR;
            LS_LOG_RESULT(lsReturn);
            goto ErrorReturn;
        }
        
    }
    else
    {
        //
        // Do Hydra server authentication by validating the server certificate
        //
        
        DWORD
            dwCertVersion;

        if( ( 0 >= pCanonical->ServerCert.wBlobLen ) ||
            ( NULL == pCanonical->ServerCert.pBlob ) )
        {
            //
            // make sure that we have received a certificate from the server
            //

            lsReturn = LICENSE_STATUS_NO_CERTIFICATE;
            LS_LOG_RESULT(lsReturn);
            goto ErrorReturn;
        }

        //
        // Determine the version of the certificate so that we can decode and
        // validate it correctly.
        //

        memcpy( ( char * )&dwCertVersion, pCanonical->ServerCert.pBlob, sizeof( DWORD ) );      
        
        if( CERT_CHAIN_VERSION_2 > dwCertVersion )
        {
            Hydra_Server_Cert ServerCert;

            //
            // Validate a proprietory certificate
            //

            memset( &ServerCert, 0, sizeof( ServerCert ) );

            if( !UnpackServerCert(pCanonical->ServerCert.pBlob,
                                  (DWORD)pCanonical->ServerCert.wBlobLen,
                                  &ServerCert) )
            {
                lsReturn = LICENSE_STATUS_UNSPECIFIED_ERROR;
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
        
            //Now verify the signature on the server certificate

            if(!ValidateServerCert(&ServerCert) )
            {
                lsReturn = LICENSE_STATUS_UNSPECIFIED_ERROR;
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            else
            {
                //
                // free any old certificate and remember the new one.
                //

                if( pContext->pServerCert )
                {
                    FreeProprietaryCertificate( &pContext->pServerCert );
                }
            
                lsReturn = LicenseSetCertificate( 
                                        ( HANDLE )pContext,
                                        &ServerCert );

                if( LICENSE_STATUS_OK != lsReturn )
                {
                    LS_LOG_RESULT( lsReturn );
                    goto ErrorReturn;
                }
            }
        }
        else
        {
            DWORD
                fDates =  CERT_DATE_DONT_VALIDATE;

            //
            // X509 certificate
            //

            //
            // this first call finds out the memory required for the public key
            //

            lsReturn = VerifyCertChain( pCanonical->ServerCert.pBlob, 
                                        ( DWORD )pCanonical->ServerCert.wBlobLen,
                                        NULL, 
                                        &pContext->cbServerPubKey,
                                        &fDates );

            if( LICENSE_STATUS_INSUFFICIENT_BUFFER == lsReturn )
            {
                if( pContext->pbServerPubKey )
                {
                    free( pContext->pbServerPubKey );
                }

                pContext->pbServerPubKey = malloc( pContext->cbServerPubKey );

                if( NULL == pContext->pbServerPubKey )
                {
                    lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
                    LS_LOG_RESULT(lsReturn);
                    goto ErrorReturn;
                }

                lsReturn = VerifyCertChain( pCanonical->ServerCert.pBlob, 
                                            ( DWORD )pCanonical->ServerCert.wBlobLen,
                                            pContext->pbServerPubKey, 
                                            &pContext->cbServerPubKey,
                                            &fDates );
            }

            if( LICENSE_STATUS_OK != lsReturn )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
        }
    }

    if(pContext->pCryptParam == NULL)
    {
        lsReturn = LICENSE_STATUS_INITIALIZATION_FAILED;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    //Copy Server Random to pCryptSystem->rgbServerRandom
    memcpy(pContext->pCryptParam->rgbServerRandom, pCanonical->ServerRandom, LICENSE_RANDOM);
    
    LicenseDebugOutput("Server Random : \n");
    LS_DUMPSTRING(LICENSE_RANDOM, pContext->pCryptParam->rgbServerRandom);

    //Generate 32 byte Client Random
    if (!TSRNG_GenerateRandomBits(Random, LICENSE_RANDOM))
    {
        lsReturn = LICENSE_STATUS_CONTEXT_INITIALIZATION_ERROR;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Copy ClientRandom to pContext->pCryptParam
    memcpy(pContext->pCryptParam->rgbClientRandom, Random, LICENSE_RANDOM);
    
    LicenseDebugOutput("Client Random : \n");
    LS_DUMPSTRING(LICENSE_RANDOM, pContext->pCryptParam->rgbClientRandom);
    
    //Generate 48 byte long PreMasterSecret
    if (!TSRNG_GenerateRandomBits(PreMasterSecret, LICENSE_PRE_MASTER_SECRET))
    {
        lsReturn = LICENSE_STATUS_CONTEXT_INITIALIZATION_ERROR;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    LicenseDebugOutput("Pre Master Secret : \n");
    LS_DUMPSTRING(LICENSE_PRE_MASTER_SECRET, PreMasterSecret);

    //Copy Premastersecret to pCryptParam
    lsReturn = LicenseSetPreMasterSecret(pContext->pCryptParam, PreMasterSecret);
    
    
    //Search in the store to find an appropriate License

    //To do that, first open the system store.
    if( LICENSE_STATUS_OK != (lsReturn = MapStoreError(LSOpenLicenseStore(&hStore, NULL, TRUE))) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    //Initialize lsIndex structure with the values sent by the Server
    lsIndex.dwVersion = pCanonical->ProductInfo.dwVersion;
    lsIndex.cbCompany = pCanonical->ProductInfo.cbCompanyName;

    if( NULL == (lsIndex.pbCompany = (LPSTR)malloc(lsIndex.cbCompany)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    memset(lsIndex.pbCompany, 0x00, lsIndex.cbCompany); 
    memcpy(lsIndex.pbCompany, pCanonical->ProductInfo.pbCompanyName, lsIndex.cbCompany); 
    
    lsIndex.cbProductID = pCanonical->ProductInfo.cbProductID;

    if( NULL == (lsIndex.pbProductID = (LPSTR)malloc(lsIndex.cbProductID)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    memset(lsIndex.pbProductID, 0x00, lsIndex.cbProductID); 
    memcpy(lsIndex.pbProductID, pCanonical->ProductInfo.pbProductID, lsIndex.cbProductID ); 
    
    for(dwCount=0; dwCount<pCanonical->ScopeList.dwScopeCount; dwCount ++)
    {
        DWORD dwProtVer = PREAMBLE_VERSION_1_0;
        lsIndex.cbScope = pCanonical->ScopeList.Scopes[dwCount].wBlobLen;
        if( NULL == (lsIndex.pbScope = (LPSTR)malloc(lsIndex.cbScope)) )
        {
            lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
            LS_LOG_RESULT(lsReturn);
            continue;
        }
        
        //Initialize pszScope member of the lsIndex with the ith element in the scopelist
        memset(lsIndex.pbScope, 0x00, lsIndex.cbScope);
        memcpy(lsIndex.pbScope, pCanonical->ScopeList.Scopes[dwCount].pBlob, lsIndex.cbScope);
                
        if( LICENSE_STATUS_OK != (lsReturn = MapStoreError(LSFindLicenseInStore(hStore, 
                                                                                &lsIndex, 
                                                                                &cbData, 
                                                                                NULL))) )
        {
            if(lsIndex.pbScope) 
            {
                free(lsIndex.pbScope);
                lsIndex.pbScope = NULL;
            }
            continue;
        }

        //
        // NOTE:  this line was previously
        // if(pContext->dwProtocolVersion != PREAMBLE_VERSION_2_0) for
        // Hydra 4.0 clients, which means that a pseudo license will be
        // generated for licensing protocol later than 2.0 as well!
        // To overcome this problem, Hydra 5.0 server will use the 
        // PREAMBLE_VERSION_2_0 for Hydra 4.0 clients.
        //

        if( GET_PREAMBLE_VERSION( pContext->dwProtocolVersion ) < PREAMBLE_VERSION_2_0)
        {
            if( !GeneratePseudoLicense(&cbData, &pbData) )
            {
                lsReturn = LICENSE_STATUS_UNSPECIFIED_ERROR;
                if(lsIndex.pbScope)
                {
                    free(lsIndex.pbScope);
                    lsIndex.pbScope = NULL;
                }
                goto ErrorReturn;
            }
            lsReturn = LICENSE_STATUS_OK;
            if(lsIndex.pbScope)
            {
                free(lsIndex.pbScope);
                lsIndex.pbScope = NULL;
            }
            break;
        }
        if(cbData == 0)
        {
            if(lsIndex.pbScope)
            {
                free(lsIndex.pbScope);
                lsIndex.pbScope = NULL;
            }
            continue;
        }   
        if( NULL == (pbData=(BYTE FAR *)malloc(cbData)) )
        {   
            if(lsIndex.pbScope)
            {
                free(lsIndex.pbScope);
                lsIndex.pbScope = NULL;
            }
            lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
            continue;
        }
        if( LICENSE_STATUS_OK != (lsReturn = MapStoreError(LSFindLicenseInStore(hStore, 
                                                                                &lsIndex, 
                                                                                &cbData, 
                                                                                pbData))) )
        {
            if(lsIndex.pbScope)
            {
                free(lsIndex.pbScope);
                lsIndex.pbScope = NULL;
            }
            continue;
        }
        
        LicenseDebugOutput("License Info Data : \n");
        LS_DUMPSTRING(cbData, pbData);

        lsReturn = LICENSE_STATUS_OK;
        if(lsIndex.pbScope)
        {
            free(lsIndex.pbScope);
            lsIndex.pbScope = NULL;
        }
        break;
    }

    //If a license is found in the store, then Continue with Hydra_Client_License_Info message
    if( LICENSE_STATUS_OK == lsReturn )
    {
        if( LICENSE_STATUS_CONTINUE != (lsReturn = ClientConstructLicenseInfo(pContext, 
                                                                        pbData, 
                                                                        cbData, 
                                                                        pbMessage, 
                                                                        pcbMessage,
                                                                        fExtendedError)) )
        {
            LS_LOG_RESULT(lsReturn);
            goto ErrorReturn;
        }
        goto CommonReturn;
    }

    //Else if no license if found, then depending on fNewLicense, either Request for a new license
    //or, abort connection

    else if(lsReturn == LICENSE_STATUS_NO_LICENSE_ERROR)
    {
        if(fNewLicense)
        {
            if( LICENSE_STATUS_CONTINUE != (lsReturn = ClientConstructNewLicenseRequest(pContext, 
                                                                                  pbMessage, 
                                                                                  pcbMessage,
                                                                                  fExtendedError)) )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            goto CommonReturn;
        }
        else    //Generate an error message and close connection
        {
            if( LICENSE_STATUS_CLIENT_ABORT != (lsReturn = ClientConstructErrorAlert(pContext, 
                                                                           GM_HC_ERR_NO_LICENSE, 
                                                                           ST_TOTAL_ABORT,
                                                                           NULL,
                                                                           0,
                                                                           pbMessage,
                                                                           pcbMessage,
                                                                           fExtendedError
                                                                           )) )
            {
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
        }
    }

    LS_LOG_RESULT(lsReturn);

CommonReturn:

    //
    // close license store
    //
    
    if( hStore )
    {
        LSCloseLicenseStore(hStore);
        hStore = NULL;
    }
    
    if(pbData)
    {
        free(pbData);
        pbData = NULL;
    }
    if(lsIndex.pbCompany)
    {
        free(lsIndex.pbCompany);
        lsIndex.pbCompany = NULL;
    }
    if(lsIndex.pbProductID)
    {
        free(lsIndex.pbProductID);
        lsIndex.pbProductID = NULL;
    }
    if(lsIndex.pbScope)
    {
        free(lsIndex.pbScope);
        lsIndex.pbScope = NULL;
    }
    return lsReturn;
    //LS_RETURN(lsReturn);
ErrorReturn:
    *pcbMessage = 0;

    if( pContext != NULL)
    {
        if(pContext->pServerCert)
        {
            free(pContext->pServerCert);
            pContext->pServerCert = NULL;
        }

        if( pContext->pbServerPubKey )
        {
            free( pContext->pbServerPubKey );
            pContext->pbServerPubKey = NULL;
        }
    }

    goto CommonReturn;
}


LICENSE_STATUS
CALL_TYPE
LicenseClientHandleServerPlatformChallenge(
                               PLicense_Client_Context          pContext,
                               PHydra_Server_Platform_Challenge pCanonical,
                               BYTE FAR *                       pbMessage,
                               DWORD FAR *                      pcbMessage,
                               BOOL                             fExtendedError
                               )
{
    LICENSE_STATUS      lsReturn = LICENSE_STATUS_OK;
    Hydra_Client_Platform_Challenge_Response    Response;
    
    BYTE                MACData[LICENSE_MAC_DATA];
    HWID                hwid;
    BYTE FAR *          pbData = NULL;
    UCHAR *             LocalBuf = NULL;
    DWORD               cbData = 0;

    LS_BEGIN(TEXT("LicenseClientHandleServerPlatformChallenge"));


    if( (pContext == NULL) || (pCanonical == NULL) || (pcbMessage == NULL) )
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }


    memset(&Response, 0x00, sizeof(Hydra_Client_Platform_Challenge_Response));

    
    if( (pContext->dwState != LICENSE_CLIENT_STATE_LICENSE_RESPONSE) &&
        (pContext->dwState != LICENSE_CLIENT_STATE_NEW_LICENSE_REQUEST) )
    {
        lsReturn = LICENSE_STATUS_INVALID_CLIENT_STATE;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //First decrypt the encrypted platform challenge
    if( LICENSE_STATUS_OK != (lsReturn = LicenseDecryptSessionData(pContext->pCryptParam,
                                                                  pCanonical->EncryptedPlatformChallenge.pBlob,
                                                                  (DWORD)pCanonical->EncryptedPlatformChallenge.wBlobLen)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    //Generate the MAC with the decrypted platform Challenge
    if( LICENSE_STATUS_OK != (lsReturn = LicenseGenerateMAC(pContext->pCryptParam,
                                                            pCanonical->EncryptedPlatformChallenge.pBlob,
                                                            (DWORD)pCanonical->EncryptedPlatformChallenge.wBlobLen,
                                                           MACData
                                                           )) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    LicenseDebugOutput(" Client generated MAC data to verify Server's message Authenticity : \n");
    LS_DUMPSTRING(LICENSE_MAC_DATA, MACData);
    

    //Compare the generated MAC with the one sent by the server
    if( memcmp(MACData, pCanonical->MACData, LICENSE_MAC_DATA) )
    {
        lsReturn = LICENSE_STATUS_INVALID_MAC_DATA;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Generate Platform Challenge Response
    if( LICENSE_STATUS_OK != (lsReturn = ClientGenerateChallengeResponse(pContext,
                                                                         &pCanonical->EncryptedPlatformChallenge,
                                                                         &Response.EncryptedChallengeResponse)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;

    }

    //Generate HWID, Encrypt it using the Session key and put it in the Response
    memset(&hwid, 0x00, sizeof(HWID));
    if( LICENSE_STATUS_OK != (lsReturn = GenerateClientHWID(&hwid)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }


    //GenerateClientHWID(&hwid);
    LicenseDebugOutput("HWID in byte : \n");

    LS_DUMPSTRING(sizeof(HWID), (BYTE FAR *)&hwid);


    Response.EncryptedHWID.wBlobType = BB_DATA_BLOB;
    Response.EncryptedHWID.wBlobLen = sizeof(HWID);
    if( NULL == (Response.EncryptedHWID.pBlob = (BYTE FAR *)malloc(Response.EncryptedHWID.wBlobLen)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    memset(Response.EncryptedHWID.pBlob, 0x00, Response.EncryptedHWID.wBlobLen);
    memcpy(Response.EncryptedHWID.pBlob, &hwid, Response.EncryptedHWID.wBlobLen);
    
    if( NULL == (LocalBuf = (UCHAR *)malloc(Response.EncryptedChallengeResponse.wBlobLen + 
        Response.EncryptedHWID.wBlobLen)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    cbData += Response.EncryptedChallengeResponse.wBlobLen;
    memcpy(LocalBuf, Response.EncryptedChallengeResponse.pBlob, Response.EncryptedChallengeResponse.wBlobLen);
    memcpy(LocalBuf + cbData, Response.EncryptedHWID.pBlob, Response.EncryptedHWID.wBlobLen);
    cbData += Response.EncryptedHWID.wBlobLen;
    
    //Generate MACData and put it in the Response
    if( LICENSE_STATUS_OK != (lsReturn = LicenseGenerateMAC(pContext->pCryptParam,
                                                            LocalBuf,
                                                            cbData,
                                                            Response.MACData)) )
    {
        free(LocalBuf);
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    free(LocalBuf);

    //Now encrypt the platform challenge response using the negotiated session key
    if( LICENSE_STATUS_OK != (lsReturn = LicenseEncryptSessionData(pContext->pCryptParam,
                                                                   Response.EncryptedChallengeResponse.pBlob,
                                                                   Response.EncryptedChallengeResponse.wBlobLen
                                                                   )) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Encrypt the HWID with generated session key
    if( LICENSE_STATUS_OK != (lsReturn = LicenseEncryptSessionData(pContext->pCryptParam, 
                                                                   Response.EncryptedHWID.pBlob,
                                                                   (DWORD)Response.EncryptedHWID.wBlobLen)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Now we have our Platform challenge Response Ready. Pack the data in a byte stream
    if( LICENSE_STATUS_OK != (lsReturn = PackHydraClientPlatformChallengeResponse(&Response,
                                                                                  fExtendedError,
                                                                                  pbMessage,
                                                                                  pcbMessage)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    // Set appropriate state and data in proper places
    
    //Set the MACData in the CryptSystem MAC buffer.
    memcpy(pContext->rgbMACData, Response.MACData, LICENSE_MAC_DATA);
    
    //Set the state of the context to LICENSE_CLIENT_STATE_PLATFORM_CHALLENGE_RESPONSE
    //provided data was written in the  output. i.e pbMessage is not NULL

    if(pbMessage)
        pContext->dwState = LICENSE_CLIENT_STATE_PLATFORM_CHALLENGE_RESPONSE;

    //Copy the whole message to the context
    pContext->cbLastMessage = *pcbMessage;
    if(pbMessage)
    {
        if( pContext->pbLastMessage )
        {
            free( pContext->pbLastMessage );
        }

        if( NULL == (pContext->pbLastMessage = (BYTE FAR *)malloc(pContext->cbLastMessage)) )
        {
            lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
            LS_LOG_RESULT(lsReturn);
            goto ErrorReturn;
        }
        memset(pContext->pbLastMessage, 0x00, pContext->cbLastMessage);
        memcpy(pContext->pbLastMessage, pbMessage, pContext->cbLastMessage);
    }

    lsReturn = LICENSE_STATUS_CONTINUE;

    LS_LOG_RESULT(lsReturn);                                                                         
CommonReturn:
    //LICENSE_LOG_RESULT(lsReturn);

    if(Response.EncryptedChallengeResponse.pBlob)
    {
        free(Response.EncryptedChallengeResponse.pBlob);
        Response.EncryptedChallengeResponse.pBlob = NULL;
    }
    if(Response.EncryptedHWID.pBlob)
    {
        free(Response.EncryptedHWID.pBlob);
        Response.EncryptedHWID.pBlob = NULL;
    }
    return lsReturn;
    //LS_RETURN(lsReturn);
ErrorReturn:
    *pcbMessage = 0;
    goto CommonReturn;
}

LICENSE_STATUS
CALL_TYPE
LicenseClientHandleNewLicense(
                               PLicense_Client_Context      pContext,
                               PHydra_Server_New_License    pCanonical,
                               BOOL                         fNew,
                               BYTE FAR *                   pbMessage,
                               DWORD FAR *                  pcbMessage
                               )
{
    LICENSE_STATUS      lsReturn = LICENSE_STATUS_OK;
    New_License_Info    NewLicense;
    BYTE                MACData[LICENSE_MAC_DATA];
    Binary_Blob         bbData;
    LSINDEX             lsIndex;
    HANDLE              hStore = NULL;

    LS_BEGIN(TEXT("LicenseClientHandleNewLicense"));

    if(NULL == pContext || NULL == pCanonical )
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    memset(&bbData, 0x00, sizeof(Binary_Blob));
    memset(&NewLicense, 0x00, sizeof(New_License_Info));
    memset(&lsIndex, 0x00, sizeof(LSINDEX));

    //First decrypt the encrypted license info
    if( LICENSE_STATUS_OK != (lsReturn = LicenseDecryptSessionData(pContext->pCryptParam,
                                                                   pCanonical->EncryptedNewLicenseInfo.pBlob,
                                                                   ( DWORD )( pCanonical->EncryptedNewLicenseInfo.wBlobLen ))) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Generate the MAC data with the decrypted data
    if( LICENSE_STATUS_OK != (lsReturn = LicenseGenerateMAC(pContext->pCryptParam,
                                                            pCanonical->EncryptedNewLicenseInfo.pBlob,
                                                            (DWORD)pCanonical->EncryptedNewLicenseInfo.wBlobLen,
                                                            MACData)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Compare this MAC with the one sent by the Server.
    if(memcmp(MACData, pCanonical->MACData, LICENSE_MAC_DATA))
    {
        lsReturn = LICENSE_STATUS_INVALID_MAC_DATA;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    if( LICENSE_STATUS_OK != (lsReturn = UnpackNewLicenseInfo(pCanonical->EncryptedNewLicenseInfo.pBlob,
                                                             (DWORD)pCanonical->EncryptedNewLicenseInfo.wBlobLen,
                                                              &NewLicense)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    //Try to open the system license store
    if( LICENSE_STATUS_OK != (lsReturn = MapStoreError(LSOpenLicenseStore(&hStore, NULL, FALSE))) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }   
    
    //Initialize the LSINDEX structure. This structure will be used to add/replace a license in the store

    //To do that, first initialize version info
    lsIndex.dwVersion = NewLicense.dwVersion;

    //Initialize Scope info
    lsIndex.cbScope = NewLicense.cbScope;
    if( NULL == (lsIndex.pbScope = (LPSTR)malloc(lsIndex.cbScope)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    memset(lsIndex.pbScope, 0x00, lsIndex.cbScope);
    memcpy(lsIndex.pbScope, NewLicense.pbScope, lsIndex.cbScope);
    

    //Initialize CompanyName info
    lsIndex.cbCompany = NewLicense.cbCompanyName;
    if( NULL == (lsIndex.pbCompany = (LPSTR)malloc(lsIndex.cbCompany)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    memset(lsIndex.pbCompany, 0x00, lsIndex.cbCompany);
    memcpy(lsIndex.pbCompany, NewLicense.pbCompanyName, lsIndex.cbCompany);
    

    //Initialize ProductID info
    lsIndex.cbProductID = NewLicense.cbProductID;
    if( NULL == (lsIndex.pbProductID = (LPSTR)malloc(lsIndex.cbProductID)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    memset(lsIndex.pbProductID, 0x00, lsIndex.cbProductID);
    memcpy(lsIndex.pbProductID, NewLicense.pbProductID, lsIndex.cbProductID);
    
    
    LS_LOG_RESULT(lsReturn);
    
    if( LICENSE_STATUS_OK != (lsReturn = LSAddLicenseToStore(hStore,
                                                             LS_REPLACE_LICENSE_OK,
                                                             &lsIndex,
                                                             NewLicense.pbLicenseInfo,
                                                             NewLicense.cbLicenseInfo
                                                             )) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    
    //Update state info and inform that the License Verification is over and the client can carry on 
    //with further connection!
    pContext->dwState = LICENSE_CLIENT_STATE_DONE;

    memset(pContext->rgbMACData, 0x00, LICENSE_MAC_DATA);

    //Reset the last send message to 0;
    if(pContext->pbLastMessage)
    {
        memset(pContext->pbLastMessage, 0x00, pContext->cbLastMessage);
        free(pContext->pbLastMessage);
        pContext->pbLastMessage = NULL;
    }
    pContext->cbLastMessage = 0;
    
    lsReturn = LICENSE_STATUS_OK;

CommonReturn:
    
    if( hStore )
    {
        LSCloseLicenseStore( hStore );
    }

    if(NewLicense.pbScope)
    {
        free(NewLicense.pbScope);
        NewLicense.pbScope = NULL;
    }
    
    if(NewLicense.pbCompanyName)
    {
        free(NewLicense.pbCompanyName);
        NewLicense.pbCompanyName = NULL;
    }

    if(NewLicense.pbProductID)
    {
        free(NewLicense.pbProductID);
        NewLicense.pbProductID = NULL;
    }

    if(NewLicense.pbLicenseInfo)
    {
        free(NewLicense.pbLicenseInfo);
        NewLicense.pbLicenseInfo = NULL;
    }

    if(lsIndex.pbScope)
    {
        free(lsIndex.pbScope);
        lsIndex.pbScope = NULL;
    }

    if(lsIndex.pbCompany)
    {
        free(lsIndex.pbCompany);
        lsIndex.pbCompany = NULL;
    }
    if(lsIndex.pbProductID)
    {
        free(lsIndex.pbProductID);
        lsIndex.pbProductID = NULL;
    }

    if(bbData.pBlob)
    {
        free(bbData.pBlob);
        bbData.pBlob = NULL;
    }

    return lsReturn;

ErrorReturn:
    goto CommonReturn;
}


LICENSE_STATUS 
CALL_TYPE
ClientConstructLicenseInfo(
                           PLicense_Client_Context  pContext,
                           BYTE FAR *               pbInput,
                           DWORD                    cbInput,
                           BYTE FAR *               pbOutput,
                           DWORD    FAR *           pcbOutput,
                           BOOL                     fExtendedError
                           )
{
    LICENSE_STATUS      lsReturn = LICENSE_STATUS_OK;
    Hydra_Client_License_Info   Canonical;
    HWID                        hwid;
    Binary_Blob                 bbPreMasterSecret;
    DWORD                       dwSize = 0;
    DWORD                       dwState = 0;
    PBYTE                       pbServerPubKey;
    DWORD                       cbServerPubKey;

    LS_BEGIN(TEXT("ClientContstructLicenseInfo"));

    if(NULL == pContext || NULL == pcbOutput)
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }    
    
    //Construct the messages
    bbPreMasterSecret.wBlobType = BB_RANDOM_BLOB;
    bbPreMasterSecret.wBlobLen = LICENSE_PRE_MASTER_SECRET;
    if( NULL == (bbPreMasterSecret.pBlob = (BYTE FAR *)malloc(LICENSE_PRE_MASTER_SECRET)) )
    {
    
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    memcpy(bbPreMasterSecret.pBlob, pContext->pCryptParam->rgbPreMasterSecret, LICENSE_PRE_MASTER_SECRET);
    memset(&Canonical, 0x00, sizeof(Hydra_Client_License_Info));

    //RSA is hardcoded for the time being
    Canonical.dwPrefKeyExchangeAlg = pContext->pCryptParam->dwKeyExchAlg;
    
#ifdef OS_WINCE
    Canonical.dwPlatformID =  CLIENT_OS_ID_OTHER | CLIENT_IMAGE_ID_MICROSOFT;
#else   // WinNT or Win9x
    {
        DWORD dwVersion = GetVersion();

        if (dwVersion & 0x80000000) {
            // Win95
            Canonical.dwPlatformID = CLIENT_OS_ID_OTHER | CLIENT_IMAGE_ID_MICROSOFT;
        } else {

            OSVERSIONINFOEX ovix;
            BOOL b;       
            ovix.dwOSVersionInfoSize = sizeof(ovix);
            b = GetVersionEx((LPOSVERSIONINFO) &ovix);            
            if(b && ((ovix.wSuiteMask & VER_SUITE_EMBEDDEDNT) || (ovix.wSuiteMask & VER_SUITE_PERSONAL)))
            {
                Canonical.dwPlatformID = CLIENT_OS_ID_WINNT_40 | CLIENT_IMAGE_ID_MICROSOFT;
            }            
            else
            {

                // WinNT
                Canonical.dwPlatformID = CLIENT_IMAGE_ID_MICROSOFT |
                    ((((DWORD)(LOBYTE(LOWORD(dwVersion)))) - 2) << 24);
			    
			    Canonical.dwPlatformID |= (DWORD)(HIBYTE(LOWORD(dwVersion)));
            }
		
        }
    }
#endif

    //ClientRandom
    memcpy(Canonical.ClientRandom, pContext->pCryptParam->rgbClientRandom, LICENSE_RANDOM);
    
    if( pContext->pServerCert )
    {
        //
        // This public key is used for pre-Hydra 5.0 servers that are using proprietory
        // server certificates.
        //

        pbServerPubKey = pContext->pServerCert->PublicKeyData.pBlob;
        cbServerPubKey = pContext->pServerCert->PublicKeyData.wBlobLen;
    }
    else
    {
        pbServerPubKey = pContext->pbServerPubKey;
        cbServerPubKey = pContext->cbServerPubKey;
    }

    //We have to switch here depending on the key exchange algorithm to be used -Shubho
    if( LICENSE_STATUS_OK != (lsReturn = LicenseEnvelopeData(pbServerPubKey,
                                                             cbServerPubKey,
                                                             bbPreMasterSecret.pBlob,
                                                             bbPreMasterSecret.wBlobLen,
                                                             NULL,
                                                             &dwSize)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    if( NULL == (Canonical.EncryptedPreMasterSecret.pBlob = (BYTE FAR *)malloc(dwSize)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    memset(Canonical.EncryptedPreMasterSecret.pBlob, 0x00, dwSize);
    
    if( LICENSE_STATUS_OK != (lsReturn = LicenseEnvelopeData(pbServerPubKey,
                                                             cbServerPubKey,
                                                             bbPreMasterSecret.pBlob,
                                                             bbPreMasterSecret.wBlobLen,
                                                             Canonical.EncryptedPreMasterSecret.pBlob,
                                                             &dwSize)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    Canonical.EncryptedPreMasterSecret.wBlobLen = (WORD)dwSize;

    //Fill up LicenseInfo buffer
    Canonical.LicenseInfo.wBlobType = BB_DATA_BLOB;
    Canonical.LicenseInfo.wBlobLen = (WORD)cbInput;
    if( NULL == (Canonical.LicenseInfo.pBlob = (BYTE FAR *)malloc(Canonical.LicenseInfo.wBlobLen)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    memset(Canonical.LicenseInfo.pBlob, 0x00, Canonical.LicenseInfo.wBlobLen);
    memcpy(Canonical.LicenseInfo.pBlob, pbInput, Canonical.LicenseInfo.wBlobLen);
    

    //Generate HWID and put the data in a binary_blob to encrypt
    memset(&hwid, 0x00, sizeof(HWID));
    
    if( LICENSE_STATUS_OK != (lsReturn = GenerateClientHWID(&hwid)) )
    {   
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    Canonical.EncryptedHWID.wBlobType = BB_DATA_BLOB;
    Canonical.EncryptedHWID.wBlobLen = sizeof(HWID);
    if( NULL == (Canonical.EncryptedHWID.pBlob = (BYTE FAR *)malloc(Canonical.EncryptedHWID.wBlobLen)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    memset(Canonical.EncryptedHWID.pBlob, 0x00, Canonical.EncryptedHWID.wBlobLen);
    memcpy(Canonical.EncryptedHWID.pBlob, &hwid, Canonical.EncryptedHWID.wBlobLen);

    dwState = pContext->pCryptParam->dwCryptState;
    //Generate the session key and MACsalt
    if( LICENSE_STATUS_OK != (lsReturn = LicenseBuildMasterSecret(pContext->pCryptParam)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    if( LICENSE_STATUS_OK != (lsReturn = LicenseMakeSessionKeys(pContext->pCryptParam, 0)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Encrypt the HWID with generated session key
    if( LICENSE_STATUS_OK != (lsReturn = LicenseEncryptSessionData(pContext->pCryptParam, 
                                                                   Canonical.EncryptedHWID.pBlob,
                                                                   (DWORD)Canonical.EncryptedHWID.wBlobLen)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    //Generate the MAC with original HWID
    LicenseGenerateMAC(pContext->pCryptParam, ( BYTE FAR * )&hwid, sizeof(hwid), Canonical.MACData);
    
    //Now everything is ready, so pack the data 
    if( LICENSE_STATUS_OK != (lsReturn = PackHydraClientLicenseInfo(&Canonical, fExtendedError, pbOutput, pcbOutput)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    //Set the MACData in the CryptSystem MAC buffer.
    memcpy(pContext->rgbMACData, Canonical.MACData, LICENSE_MAC_DATA);
    
    //Set the state of the context to LICENSE_CLIENT_STATE_LICENSE_RESPONSE
    //if any output data is written. i.e. pbOutput is not null. Also revert back
    //the crypparam state as this will also be called twice and we change the state
    //only when we have written something in the output!!!!! - bad!!!!!
    if(pbOutput)
    {
        pContext->dwState = LICENSE_CLIENT_STATE_LICENSE_RESPONSE;
    }
    
    else    //Restore earlier CryptSystem States
    {
        pContext->pCryptParam->dwCryptState = dwState;
        memcpy(pContext->pCryptParam->rgbPreMasterSecret, bbPreMasterSecret.pBlob, LICENSE_PRE_MASTER_SECRET);
        memset(pContext->pCryptParam->rgbSessionKey, 0x00, LICENSE_SESSION_KEY);
        memset(pContext->pCryptParam->rgbMACSaltKey, 0x00, LICENSE_MAC_WRITE_KEY);
    }

    //Copy the whole message to the context
    pContext->cbLastMessage = *pcbOutput;
    if(pbOutput)
    {
        if( pContext->pbLastMessage )
        {
            free( pContext->pbLastMessage );
        }

        if( NULL == (pContext->pbLastMessage = (BYTE FAR *)malloc(pContext->cbLastMessage)) )
        {
            lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
            goto ErrorReturn;
        }
        memset(pContext->pbLastMessage, 0x00, pContext->cbLastMessage);
        memcpy(pContext->pbLastMessage, pbOutput, pContext->cbLastMessage);
    }

    lsReturn = LICENSE_STATUS_CONTINUE;
    LS_LOG_RESULT(lsReturn);
CommonReturn:
    
    if(Canonical.EncryptedPreMasterSecret.pBlob)
    {
        free(Canonical.EncryptedPreMasterSecret.pBlob);
        Canonical.EncryptedPreMasterSecret.pBlob = NULL;
    }

    if(Canonical.LicenseInfo.pBlob)
    {
        free(Canonical.LicenseInfo.pBlob);
        Canonical.LicenseInfo.pBlob = NULL;
    }

    if(Canonical.EncryptedHWID.pBlob)
    {
        free(Canonical.EncryptedHWID.pBlob);
        Canonical.EncryptedHWID.pBlob = NULL;
    }
    
    if(bbPreMasterSecret.pBlob)
    {
        free(bbPreMasterSecret.pBlob);
        bbPreMasterSecret.pBlob = NULL;
    }

    return  lsReturn;
//  LS_RETURN(lsReturn);
ErrorReturn:
    *pcbOutput = 0;
    goto CommonReturn;
}

LICENSE_STATUS 
CALL_TYPE
ClientConstructNewLicenseRequest(
                           PLicense_Client_Context  pContext,
                           BYTE FAR *               pbOutput,
                           DWORD FAR *              pcbOutput,
                           BOOL                     fExtendedError
                           )
{
    LICENSE_STATUS      lsReturn = LICENSE_STATUS_OK;
    Hydra_Client_New_License_Request    Request;
    Binary_Blob                         bbPreMasterSecret;
    DWORD                               dwSize = 0;
    DWORD                               dwState = 0;

#ifdef OS_WINCE

#define LS_MAX(a,b) ((a) > (b) ? (a) : (b))

    BYTE                                szUserName[LS_MAX((UNLEN + 1),HWID_STR_LEN)];
    DWORD                               cbUserName = sizeof(szUserName);
    BYTE                                szMachineName[LS_MAX(MAX_COMPUTERNAME_LENGTH + 1,HWID_STR_LEN)];
    DWORD                               cbMachineName = sizeof(szMachineName);

#else

    BYTE                                szUserName[(UNLEN + 1) * sizeof(TCHAR)];
    DWORD                               cbUserName = UNLEN + 1;
    BYTE                                szMachineName[(MAX_COMPUTERNAME_LENGTH + 1) * sizeof(TCHAR)];
    DWORD                               cbMachineName = (MAX_COMPUTERNAME_LENGTH + 1) * sizeof(TCHAR);

#endif

    PBYTE                               pbServerPubKey;
    DWORD                               cbServerPubKey;

    LS_BEGIN(TEXT("ClientConstructNewLicenseRequest"));

    if(NULL == pContext)
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    } 

    memset(szUserName,0,sizeof(szUserName));
    memset(szMachineName,0,sizeof(szMachineName));


    dwState = pContext->pCryptParam->dwCryptState;

    bbPreMasterSecret.wBlobType = BB_RANDOM_BLOB;
    bbPreMasterSecret.wBlobLen = LICENSE_PRE_MASTER_SECRET;
    if( NULL == (bbPreMasterSecret.pBlob = (BYTE FAR *)malloc(LICENSE_PRE_MASTER_SECRET)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    memcpy(bbPreMasterSecret.pBlob, pContext->pCryptParam->rgbPreMasterSecret, LICENSE_PRE_MASTER_SECRET);

    //Initialize the message
    memset(&Request, 0x00, sizeof(Hydra_Client_New_License_Request));

    //RSA is hardcoded for the time being
    Request.dwPrefKeyExchangeAlg = pContext->pCryptParam->dwKeyExchAlg;
    
    //PlatformID
#ifdef OS_WINCE
    Request.dwPlatformID =  CLIENT_OS_ID_OTHER | CLIENT_IMAGE_ID_MICROSOFT;
#else   // WinNT or Win9x
    {
        DWORD dwVersion = GetVersion();

        if (dwVersion & 0x80000000) {
            // Win95
            Request.dwPlatformID = CLIENT_OS_ID_OTHER | CLIENT_IMAGE_ID_MICROSOFT;
        } else {

            OSVERSIONINFOEX ovix;
            BOOL b;       
            ovix.dwOSVersionInfoSize = sizeof(ovix);
            b = GetVersionEx((LPOSVERSIONINFO) &ovix);            
            if(b && ((ovix.wSuiteMask & VER_SUITE_EMBEDDEDNT) || (ovix.wSuiteMask & VER_SUITE_PERSONAL)))
            {
                Request.dwPlatformID = CLIENT_OS_ID_WINNT_40 | CLIENT_IMAGE_ID_MICROSOFT;
            }            
            else
            {

                // WinNT
                Request.dwPlatformID = CLIENT_IMAGE_ID_MICROSOFT |
                ((((DWORD)(LOBYTE(LOWORD(dwVersion)))) - 2) << 24);
            }            
        }
    }
#endif

    //Copy ClientRandom
    memcpy(Request.ClientRandom, pContext->pCryptParam->rgbClientRandom, LICENSE_RANDOM);
    
    //Encrypt the Premastersecret using Server's Public key
    //We have to switch here depending on the key exchange algorithm to be used -Shubho

    if( pContext->pServerCert )
    {
        //
        // This public key is used for pre-Hydra 5.0 servers that are using proprietory
        // server certificates.
        //

        pbServerPubKey = pContext->pServerCert->PublicKeyData.pBlob;
        cbServerPubKey = pContext->pServerCert->PublicKeyData.wBlobLen;
    }
    else
    {
        pbServerPubKey = pContext->pbServerPubKey;
        cbServerPubKey = pContext->cbServerPubKey;
    }

    if( LICENSE_STATUS_OK != (lsReturn = LicenseEnvelopeData(pbServerPubKey,
                                                             cbServerPubKey,
                                                             bbPreMasterSecret.pBlob,
                                                             bbPreMasterSecret.wBlobLen,
                                                             NULL,
                                                             &dwSize)) )
    {
#if DBG
        OutputDebugString(_T("LicenseEnvelopeData failed"));
        LS_LOG_RESULT(lsReturn);
#endif
        goto ErrorReturn;
    }
    
    if( NULL == (Request.EncryptedPreMasterSecret.pBlob = (BYTE FAR *)malloc(dwSize)) )
    {
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    memset(Request.EncryptedPreMasterSecret.pBlob, 0x00, dwSize);
    
    if( LICENSE_STATUS_OK != (lsReturn = LicenseEnvelopeData(pbServerPubKey,
                                                             cbServerPubKey,
                                                             bbPreMasterSecret.pBlob,
                                                             bbPreMasterSecret.wBlobLen,
                                                             Request.EncryptedPreMasterSecret.pBlob,
                                                             &dwSize)) )
    {
#if DBG
        OutputDebugString(_T("LicenseEnvelopeData failed"));
        LS_LOG_RESULT(lsReturn);
#endif
        goto ErrorReturn;
    }

    Request.EncryptedPreMasterSecret.wBlobLen = (WORD)dwSize;

    //
    // initialize the user name binary blob
    //
#if !defined(OS_WINCE)
    GetUserName( (LPTSTR)szUserName, &cbUserName );
#elif defined(OS_WINCE)
    GetUserName( (LPSTR)szUserName, &cbUserName );
#endif  //OS_WINCE

    Request.ClientUserName.wBlobType = BB_CLIENT_USER_NAME_BLOB;
    Request.ClientUserName.wBlobLen = ( WORD )cbUserName;
    Request.ClientUserName.pBlob = szUserName;

    //
    // initialize the machine name binary blob
    //

#if defined(OS_WINCE)
    GetComputerName( (LPSTR)szMachineName, &cbMachineName );
#else
    GetComputerName( (LPTSTR)szMachineName, &cbMachineName );
#endif

    Request.ClientMachineName.wBlobType = BB_CLIENT_MACHINE_NAME_BLOB;
    Request.ClientMachineName.wBlobLen = ( WORD )cbMachineName + 1;
    Request.ClientMachineName.pBlob = szMachineName;
        
    //New License Request is ready. Now pack the data,
    if( LICENSE_STATUS_OK != (lsReturn = PackHydraClientNewLicenseRequest(&Request,
                                                                          fExtendedError,
                                                                          pbOutput, 
                                                                          pcbOutput)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Anyway Generate the session key and MACsalt for future use
    if( LICENSE_STATUS_OK != (lsReturn = LicenseBuildMasterSecret(pContext->pCryptParam)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    if( LICENSE_STATUS_OK != (lsReturn = LicenseMakeSessionKeys(pContext->pCryptParam, 0)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //Set the MACData in the CryptSystem MAC buffer.
    memset(pContext->rgbMACData, 0x00, LICENSE_MAC_DATA);

    //Set the state of the context to LICENSE_CLIENT_STATE_NEW_LICENSE_REQUEST
    //if something is written on the output. i.e. pbOutput is not NULL
    if(pbOutput)
    {
        pContext->dwState = LICENSE_CLIENT_STATE_LICENSE_RESPONSE;
    }
    
    else    //Restore earlier CryptSystem States
    {
        pContext->pCryptParam->dwCryptState = dwState;
        memcpy(pContext->pCryptParam->rgbPreMasterSecret, bbPreMasterSecret.pBlob, LICENSE_PRE_MASTER_SECRET);
        memset(pContext->pCryptParam->rgbSessionKey, 0x00, LICENSE_SESSION_KEY);
        memset(pContext->pCryptParam->rgbMACSaltKey, 0x00, LICENSE_MAC_WRITE_KEY);
    }

    //Copy the whole message to the context
    pContext->cbLastMessage = *pcbOutput;
    if(pbOutput)
    {
        if( pContext->pbLastMessage )
        {
            free( pContext->pbLastMessage );
        }

        if( NULL == (pContext->pbLastMessage = (BYTE FAR *)malloc(pContext->cbLastMessage)) )
        {
            lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
            LS_LOG_RESULT(lsReturn);
            goto ErrorReturn;
        }
        memset(pContext->pbLastMessage, 0x00, pContext->cbLastMessage);
        memcpy(pContext->pbLastMessage, pbOutput, pContext->cbLastMessage);
    }

    lsReturn = LICENSE_STATUS_CONTINUE;
    LS_LOG_RESULT(lsReturn);
CommonReturn:
    
    if(bbPreMasterSecret.pBlob)
    {
        free(bbPreMasterSecret.pBlob);
        bbPreMasterSecret.pBlob = NULL;
    }

    if( Request.EncryptedPreMasterSecret.pBlob )
    {
        free( Request.EncryptedPreMasterSecret.pBlob );
    }

    return  lsReturn;
    //LS_RETURN(lsReturn);
ErrorReturn:
    *pcbOutput = 0;
    goto CommonReturn;
}

LICENSE_STATUS
CALL_TYPE
ClientConstructErrorAlert(
                         PLicense_Client_Context    pContext,
                         DWORD                      dwErrorCode,
                         DWORD                      dwStateTransition,
                         BYTE FAR *                 pbErrorInfo,
                         DWORD                      cbErrorInfo,
                         BYTE FAR *                 pbOutput,
                         DWORD  FAR *               pcbOutput,
                         BOOL                       fExtendedError
                         )
{
    LICENSE_STATUS  lsReturn = LICENSE_STATUS_OK;
    License_Error_Message  Error;    
    
    LS_BEGIN(TEXT("ClientConstructErrorAlert\n"));

    if(NULL == pContext)
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    } 
    
    memset(&Error, 0x00, sizeof(License_Error_Message));
    Error.dwErrorCode = dwErrorCode;    
    Error.dwStateTransition = dwStateTransition;
    Error.bbErrorInfo.wBlobType = BB_ERROR_BLOB;
    Error.bbErrorInfo.wBlobLen = (WORD)cbErrorInfo;
    if(Error.bbErrorInfo.wBlobLen>0)
    {
        if( NULL == (Error.bbErrorInfo.pBlob = (BYTE FAR *)malloc(Error.bbErrorInfo.wBlobLen)) )
        {
            lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
            LS_LOG_RESULT(lsReturn);
            goto ErrorReturn;
        }
        memset(Error.bbErrorInfo.pBlob, 0x00, Error.bbErrorInfo.wBlobLen);
        memcpy(Error.bbErrorInfo.pBlob, pbErrorInfo, Error.bbErrorInfo.wBlobLen);
    }
    else
        Error.bbErrorInfo.pBlob = NULL;
    
    if( LICENSE_STATUS_OK != (lsReturn = PackLicenseErrorMessage(&Error, 
                                                                 fExtendedError,
                                                                 pbOutput, 
                                                                 pcbOutput)) )
    {
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;       
    }
    
    //Set the MACData in the CryptSystem MAC buffer.
    memset(pContext->rgbMACData, 0x00, LICENSE_MAC_DATA);

    //Set the state of the context to LICENSE_CLIENT_STATE_ABORT;
    switch(dwStateTransition)
    {
    case ST_TOTAL_ABORT:
        pContext->dwState = LICENSE_CLIENT_STATE_ABORT;
        lsReturn = LICENSE_STATUS_CLIENT_ABORT;
        pContext->cbLastMessage = 0;
        break;
    case ST_NO_TRANSITION:
        lsReturn = LICENSE_STATUS_CONTINUE;
        pContext->cbLastMessage = *pcbOutput;
        if(pbOutput)
        {
            if( pContext->pbLastMessage )
            {
                free( pContext->pbLastMessage );
            }

            if( NULL == (pContext->pbLastMessage = (BYTE FAR *)malloc(pContext->cbLastMessage)) )
            {
                lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
                LS_LOG_RESULT(lsReturn);
                goto ErrorReturn;
            }
            memset(pContext->pbLastMessage, 0x00, pContext->cbLastMessage);
            memcpy(pContext->pbLastMessage, pbOutput, pContext->cbLastMessage);
        }
        break;
    case ST_RESET_PHASE_TO_START:
        lsReturn = LICENSE_STATUS_CONTINUE;
        if( (pContext->dwState == LICENSE_CLIENT_STATE_LICENSE_RESPONSE) ||
            (pContext->dwState == LICENSE_CLIENT_STATE_NEW_LICENSE_REQUEST) )
        {
            pContext->dwState = LICENSE_CLIENT_STATE_WAIT_SERVER_HELLO;
        }
        else if(pContext->dwState == LICENSE_CLIENT_STATE_PLATFORM_CHALLENGE_RESPONSE)
        {
            pContext->dwState = LICENSE_CLIENT_STATE_NEW_LICENSE_REQUEST;
        }
        break;
    case ST_RESEND_LAST_MESSAGE:
        lsReturn = LICENSE_STATUS_CONTINUE;
        break;
    }
    
    LS_LOG_RESULT(lsReturn);    
CommonReturn:
    
    if(Error.bbErrorInfo.pBlob)
    {
        free(Error.bbErrorInfo.pBlob);
        Error.bbErrorInfo.pBlob = NULL;
    }
    return lsReturn;
    //LS_RETURN(lsReturn);
ErrorReturn:
    *pcbOutput = 0;
    goto CommonReturn;
}


LICENSE_STATUS
CALL_TYPE
ClientGenerateChallengeResponse(
                                PLicense_Client_Context     pContext,
                                PBinary_Blob                pChallengeData,
                                PBinary_Blob                pResponseData
                                )
{
    LICENSE_STATUS  lsReturn = LICENSE_STATUS_OK;
    PPlatformChallengeResponseData pbChallengeResponse = NULL;
    WORD cbChallengeResponse;


    LS_BEGIN(TEXT("ClientGenerateChallengeResponse"));

    //For the time being we will send back the same data. But we have to finalize on the challenge
    //response generation algorithm as soon as possible - Shubho
    if( (pContext == NULL) || (pChallengeData == NULL) || (pResponseData == NULL) )
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }
    
    pResponseData->wBlobType = BB_DATA_BLOB;
    
    //
    // Determine how much memory we need to allocate, PlatformChallenge* is a variable length
    // structure.
    //
    cbChallengeResponse = (WORD)OFFSET_OF(PlatformChallengeResponseData, pbChallenge) + pChallengeData->wBlobLen;

    ASSERT(cbChallengeResponse <= PLATFORM_CHALLENGE_LENGTH);
    if(cbChallengeResponse > PLATFORM_CHALLENGE_LENGTH)
    {
        lsReturn = LICENSE_STATUS_INVALID_INPUT;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    pbChallengeResponse = (PPlatformChallengeResponseData)malloc(cbChallengeResponse);
    if( NULL == pbChallengeResponse )
    {
        // can't allocate memory
        lsReturn = LICENSE_STATUS_OUT_OF_MEMORY;
        LS_LOG_RESULT(lsReturn);
        goto ErrorReturn;
    }

    //
    // Setup challenge response data, 
    //

    pbChallengeResponse->wVersion = CURRENT_PLATFORMCHALLENGE_VERSION;

 
#ifdef OS_WINCE

    pbChallengeResponse->wClientType = WINCE_PLATFORMCHALLENGE_TYPE;
    pbChallengeResponse->wLicenseDetailLevel = LICENSE_DETAIL_DETAIL;

#else

    //
    // We only need one Win32 type since we already have dwPlatformID to differentiate Win98/NT
    // Note, we set license detail level in #define just in case platform can't handle amount
    // of data set back by license server
    //
    pbChallengeResponse->wClientType = WIN32_PLATFORMCHALLENGE_TYPE;
    pbChallengeResponse->wLicenseDetailLevel = LICENSE_DETAIL_DETAIL;

#endif

    if( (pChallengeData->pBlob != NULL) && (pChallengeData->wBlobLen >0) )
    {
        pbChallengeResponse->cbChallenge = pChallengeData->wBlobLen;
        memcpy(
                (PBYTE)pbChallengeResponse + OFFSET_OF(PlatformChallengeResponseData, pbChallenge),
                pChallengeData->pBlob,
                pChallengeData->wBlobLen
            );
    }
    else
    {
        // server didn't send us any challenge data.
        pbChallengeResponse->cbChallenge = 0;
    }

    pResponseData->wBlobLen = cbChallengeResponse;
    pResponseData->pBlob = (BYTE FAR *)pbChallengeResponse;
    
    lsReturn = LICENSE_STATUS_OK;
    LS_LOG_RESULT(lsReturn);

CommonReturn:
    //LS_RETURN(lsReturn);
    return lsReturn;
ErrorReturn:
    goto CommonReturn;
}

static BOOL GeneratePseudoLicense(
                                  DWORD FAR * pcbNewLicense, 
                                  LPBYTE FAR *ppNewLicense)
{
    TCHAR g_LicenseString[] = TEXT("Licensed To Kill");

#define REPEAT_LICENSE_STRING   15
#define LICENSE_STRING_LEN      sizeof(TCHAR) * lstrlen(g_LicenseString) 

#define LICENSE_SIZE         ( LICENSE_STRING_LEN * REPEAT_LICENSE_STRING ) + 1 * sizeof(TCHAR)

    UINT i;
    BYTE FAR *pbLicenseData = NULL;
    DWORD cbLicenseData = LICENSE_SIZE;
        
    if( NULL == ( *ppNewLicense = malloc(cbLicenseData) ) )
    {   
        return FALSE;
    }

    memset(*ppNewLicense, 0x00, cbLicenseData);
    //
    // fill the memory with this license string
    //
    pbLicenseData = *ppNewLicense;
    for( i = 0; i < REPEAT_LICENSE_STRING; i++ )
    {
        memcpy( pbLicenseData, g_LicenseString, LICENSE_STRING_LEN  );
        pbLicenseData += LICENSE_STRING_LEN;
    }

    *pcbNewLicense = cbLicenseData;

    return TRUE;
}


VOID
FreeProprietaryCertificate(
    PHydra_Server_Cert * ppCertificate )
{    
    if( NULL == *ppCertificate )
    {
        return;
    }

    if( ( *ppCertificate )->PublicKeyData.pBlob )
    {
        free( ( *ppCertificate )->PublicKeyData.pBlob );
    }

    if( ( *ppCertificate )->SignatureBlob.pBlob )
    {
        free( ( *ppCertificate )->SignatureBlob.pBlob );
    }

    free( *ppCertificate );

    *ppCertificate = NULL;
}