able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/common/license/hclient/liclient/cliprot.c

2187 lines
72 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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;
}
Reference in a new issue Copy permalink