windows-nt/Source/XPSP1/NT/termsrv/license/hserver/licprot/verify.c

341 lines
9.3 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
//+----------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1996-1998
//
// File: verify.c
//
// Contents: License Verification API
//
// History: 01-21-98 FredCh Created
//
//-----------------------------------------------------------------------------
#include "precomp.h"
#include "tlsapip.h"
extern DWORD g_dwLicenseExpirationLeeway;
///////////////////////////////////////////////////////////////////////////////
LICENSE_STATUS
GetVerifyResult(
DWORD dwLicenseState )
{
switch( dwLicenseState )
{
//
// Temporary licenses verification results
//
case ( LICENSE_STATE_INVALID_PRODUCT ) :
// FALL THRU - TS5 RC1 license server bug.
case( VERIFY_RESULT_TEMP_0_0 ):
return( LICENSE_STATUS_SHOULD_UPGRADE_LICENSE );
case( VERIFY_RESULT_TEMP_EXPIRED_0 ):
return( LICENSE_STATUS_MUST_UPGRADE_LICENSE );
case( VERIFY_RESULT_TEMP_0_OLD ):
return( LICENSE_STATUS_MUST_UPGRADE_LICENSE );
case( VERIFY_RESULT_TEMP_EXPIRED_OLD ):
return( LICENSE_STATUS_MUST_UPGRADE_LICENSE );
//
// permanent license verification results
//
case( VERIFY_RESULT_0_EXPIRED_0 ):
return( LICENSE_STATUS_MUST_UPGRADE_LICENSE );
case( VERIFY_RESULT_0_EXPIRED_OLD ):
return( LICENSE_STATUS_MUST_UPGRADE_LICENSE );
case( VERIFY_RESULT_0_LEEWAY_0 ):
return( LICENSE_STATUS_SHOULD_UPGRADE_LICENSE );
case( VERIFY_RESULT_0_LEEWAY_OLD ):
return( LICENSE_STATUS_MUST_UPGRADE_LICENSE );
case( VERIFY_RESULT_0_0_OLD ):
return( LICENSE_STATUS_MUST_UPGRADE_LICENSE );
case( VERIFY_RESULT_0_0_0 ):
return( LICENSE_STATUS_OK );
default:
//
// this case should never happen. For now, if it happens, just
// let the client go through
//
// ASSERT( VERIFY_RESULT_0_EXPIRED_0 );
#if DBG
DbgPrint( "GetVerifyResult: Invalid verification result: 0x%x\n", dwLicenseState );
#endif
return( LICENSE_STATUS_INVALID_LICENSE );
// return( LICENSE_STATUS_CANNOT_DECODE_LICENSE );
}
}
///////////////////////////////////////////////////////////////////////////////
LICENSE_STATUS
VerifyClientHwid(
PHS_Protocol_Context pContext,
PValidation_Info pValidationInfo,
PLICENSEDPRODUCT pLicenseInfo )
{
HWID Hwid;
LICENSE_STATUS Status;
//
// do a memory compare of the HWID
//
if( 0 != memcmp( &pLicenseInfo->Hwid, pValidationInfo->pValidationData,
sizeof( HWID ) ) )
{
return( LICENSE_STATUS_CANNOT_VERIFY_HWID );
}
return ( LICENSE_STATUS_OK );
#if 0
#define LICENSE_MIN_MATCH_COUNT 3
HWID* pHwid;
DWORD dwMatchCount;
//
// liceapi.c, line 1023 set this to HWID
//
pHwid = (HWID *)pValidationInfo->pValidationData;
dwMatchCount = 0;
dwMatchCount += (pHwid->dwPlatformID == pLicenseInfo->Hwid.dwPlatformID);
dwMatchCount += (pHwid->Data1 == pLicenseInfo->Hwid.Data1);
dwMatchCount += (pHwid->Data2 == pLicenseInfo->Hwid.Data2);
dwMatchCount += (pHwid->Data3 == pLicenseInfo->Hwid.Data3);
dwMatchCount += (pHwid->Data4 == pLicenseInfo->Hwid.Data4);
return (dwMatchCount >= LICENSE_MIN_MATCH_COUNT) ?
LICENSE_STATUS_OK : LICENSE_STATUS_CANNOT_VERIFY_HWID;
#endif
}
///////////////////////////////////////////////////////////////////////////////
LICENSE_STATUS
VerifyLicenseProductInfo(
PHS_Protocol_Context pLmContext,
PValidation_Info pValidationInfo,
PLICENSEDPRODUCT pLicenseInfo,
PDWORD pdwLicenseState )
{
DWORD
cbCompanyName = ( wcslen( PRODUCT_INFO_COMPANY_NAME ) + 1 ) * sizeof( TCHAR ),
cbProductId = ( wcslen( PRODUCT_INFO_SKU_PRODUCT_ID ) + 1 ) * sizeof( TCHAR );
//
// Verify the company name
//
if( pLicenseInfo->LicensedProduct.pProductInfo->cbCompanyName < cbCompanyName )
{
#if DBG
DbgPrint( "LICPROT: Invalid company name in client license\n" );
#endif
// return( LICENSE_STATUS_INVALID_LICENSE );
return( LICENSE_STATUS_CANNOT_DECODE_LICENSE );
}
if ( 0 != memcmp( pLicenseInfo->LicensedProduct.pProductInfo->pbCompanyName,
PRODUCT_INFO_COMPANY_NAME, cbCompanyName ) )
{
#if DBG
DbgPrint( "LICPROT: Invalid company name in client license\n" );
#endif
// return( LICENSE_STATUS_INVALID_LICENSE );
return( LICENSE_STATUS_CANNOT_DECODE_LICENSE );
}
//
// verify the product ID
//
if( pLicenseInfo->cbOrgProductID < cbProductId )
{
// return( LICENSE_STATUS_INVALID_LICENSE );
return( LICENSE_STATUS_CANNOT_DECODE_LICENSE );
}
if( 0 != memcmp( pLicenseInfo->pbOrgProductID,
PRODUCT_INFO_SKU_PRODUCT_ID, cbProductId ) )
{
#if DBG
DbgPrint( "LICPROT: Invalid product ID in client license\n" );
#endif
// return( LICENSE_STATUS_INVALID_LICENSE );
return( LICENSE_STATUS_CANNOT_DECODE_LICENSE );
}
//
// Check actual licensed product.
//
if( pLicenseInfo->LicensedProduct.pProductInfo->cbProductID == 0 )
{
#if DBG
DbgPrint( "LICPROT: Invalid Product ID in client license\n" );
#endif
// return( LICENSE_STATUS_INVALID_LICENSE );
return( LICENSE_STATUS_CANNOT_DECODE_LICENSE );
}
if( 0 != memcmp(pLicenseInfo->LicensedProduct.pProductInfo->pbProductID,
PRODUCT_INFO_SKU_PRODUCT_ID, wcslen(PRODUCT_INFO_SKU_PRODUCT_ID) * sizeof(WCHAR)) )
{
#if DBG
DbgPrint( "LICPROT: Invalid product ID in client license\n" );
#endif
if( 0 == memcmp(pLicenseInfo->LicensedProduct.pProductInfo->pbProductID,
PRODUCT_INFO_INTERNET_SKU_PRODUCT_ID, wcslen(PRODUCT_INFO_INTERNET_SKU_PRODUCT_ID) * sizeof(WCHAR)) )
{
// TS5 beta3 RC1 license server bug, force a upgrade license.
LicenseSetState( *pdwLicenseState, LICENSE_STATE_INVALID_PRODUCT );
return( LICENSE_STATUS_OK );
}
//
// Backward compatibility - treat the new product ID as product family and
// let client connect
//
}
//
// check if this is a temporary license
//
if( pLicenseInfo->pLicensedVersion->dwFlags & 0x80000000 )
{
LicenseSetState( *pdwLicenseState, LICENSE_STATE_TEMPORARY );
}
else if(TLSIsBetaNTServer() == FALSE)
{
// verify license is issued by RTM license server
if(IS_LICENSE_ISSUER_RTM(pLicenseInfo->pLicensedVersion->dwFlags) == FALSE)
{
//LicenseSetState( *pdwLicenseState, VERIFY_RESULT_BETA_LICENSE );
return( LICENSE_STATUS_INVALID_LICENSE );
}
}
if(TLSIsLicenseEnforceEnable() == TRUE)
{
//
// W2K beta 3 to RC1 upgrade.
// Enforce TermSrv will reject any license issued by Beta 3 non-enforce license
// server.
//
if( GET_LICENSE_ISSUER_MAJORVERSION(pLicenseInfo->pLicensedVersion->dwFlags) <= 5 &&
GET_LICENSE_ISSUER_MINORVERSION(pLicenseInfo->pLicensedVersion->dwFlags) <= 2 )
{
//
// Build 20XX license server has version of 05 03, since we still need to maintain
// inter-op, we don't want to keep rejecting client holding non-enforce
// license server, so we check if license issuer is 5.2 or older.
//
if( IS_LICENSE_ISSUER_ENFORCE(pLicenseInfo->pLicensedVersion->dwFlags) == FALSE )
{
#if DBG
DbgPrint( "LICPROT: Rejecting license from non-enforce license server\n" );
#endif
return( LICENSE_STATUS_INVALID_LICENSE );
}
}
}
return( LICENSE_STATUS_OK );
}
///////////////////////////////////////////////////////////////////////////////
LICENSE_STATUS
VerifyLicenseDateAndTime(
PLICENSEDPRODUCT pLicenseInfo,
PDWORD pdwLicenseState )
{
SYSTEMTIME CurrentSysTime;
FILETIME CurrentFileTime;
LONG lReturn;
ULARGE_INTEGER ullNotAfterLeeway;
ULARGE_INTEGER ullCurrentTime;
//
// get the current system time
//
GetSystemTime( &CurrentSysTime );
//
// convert it to file time
//
SystemTimeToFileTime( &CurrentSysTime, &CurrentFileTime );
//
// Verify that the license is still valid at this time
//
lReturn = CompareFileTime( &pLicenseInfo->NotAfter, &CurrentFileTime );
if( 1 != lReturn )
{
LicenseSetState( *pdwLicenseState, LICENSE_STATE_EXPIRED );
}
else if (!(pLicenseInfo->pLicensedVersion->dwFlags & 0x80000000))
{
// permanent license
ullNotAfterLeeway.LowPart = pLicenseInfo->NotAfter.dwLowDateTime;
ullNotAfterLeeway.HighPart = pLicenseInfo->NotAfter.dwHighDateTime;
ullNotAfterLeeway.QuadPart -= Int32x32To64(g_dwLicenseExpirationLeeway,10*1000*1000);
ullCurrentTime.LowPart = CurrentFileTime.dwLowDateTime;
ullCurrentTime.HighPart = CurrentFileTime.dwHighDateTime;
if (ullNotAfterLeeway.QuadPart < ullCurrentTime.QuadPart)
{
LicenseSetState( *pdwLicenseState, LICENSE_STATE_LEEWAY );
}
}
return( LICENSE_STATUS_OK );
}