windows-nt/Source/XPSP1/NT/termsrv/license/tlserver/upg4to5/upg.cpp

1043 lines
26 KiB
C++
Raw Permalink Normal View History

2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// File: upg.cpp
//
// Contents:
//
// History:
//
//---------------------------------------------------------------------------
#include "upg.h"
#include <time.h>
//----------------------------------------------------
//
// Global variables
//
//
#ifndef LICENOC_SMALL_UPG
JBInstance g_JbInstance;
JBSession g_JetSession(g_JbInstance);
JBDatabase g_JetDatabase(g_JetSession);
PBYTE g_pbSetupId=NULL;
DWORD g_cbSetupId=0;
PBYTE g_pbDomainSid=NULL;
DWORD g_cbDomainSid=0;
TCHAR g_szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
#endif
TCHAR g_szOdbcDsn[128]=NT4LSERVER_DEFAULT_DSN; // ODBC DSN
TCHAR g_szOdbcUser[128]=NT4LSERVER_DEFAULT_USER; // ODBC User Name
TCHAR g_szOdbcPwd[128]=NT4LSERVER_DEFAULT_PWD; // ODBC Password
TCHAR g_szMdbFile[MAX_PATH+1];
//--------------------------------------------------------------------------
#ifndef LICENOC_SMALL_UPG
DWORD
UpgradeIssuedLicenseTable(
CSQLStmt* lpSqlStmt,
JBDatabase& jbDatabase
)
/*++
Note:
Transaction must be active
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
NT4LICENSE nt4License;
NT4LICENSERECORD nt4LicenseRecord(&nt4License);
LICENSEDCLIENT LicensedClient;
LicensedTable LicensedTable(jbDatabase);
TLSLicensedIndexMatchHwid hwidHint;
BOOL bSuccess;
bSuccess = LicensedTable.OpenTable(
TRUE,
JET_bitTableUpdatable
);
if(bSuccess == FALSE)
{
dwStatus = SET_JB_ERROR(LicensedTable.GetLastJetError());
SetLastError(dwStatus);
goto cleanup;
}
lpSqlStmt->Cleanup();
dwStatus = NT4LicenseEnumBegin(
lpSqlStmt,
&nt4LicenseRecord
);
if(dwStatus != ERROR_SUCCESS)
goto cleanup;
while( (dwStatus = NT4RecordEnumNext(lpSqlStmt)) == ERROR_SUCCESS )
{
memset(&LicensedClient, 0, sizeof(LicensedClient));
LicensedClient.ucEntryStatus = 0;
LicensedClient.dwLicenseId = nt4License.dwLicenseId;
LicensedClient.dwKeyPackId = nt4License.dwKeyPackId;
LicensedClient.dwKeyPackLicenseId = 0;
// LicensedClient.ftLastModifyTime;
SAFESTRCPY(LicensedClient.szMachineName, nt4License.szMachineName);
SAFESTRCPY(LicensedClient.szUserName, nt4License.szUserName);
LicensedClient.ftIssueDate = nt4License.ftIssueDate;
LicensedClient.ftExpireDate = nt4License.ftExpireDate;
LicensedClient.ucLicenseStatus = nt4License.ucLicenseStatus;
LicensedClient.dwNumLicenses = nt4License.dwNumLicenses;
LicensedClient.dwSystemBiosChkSum = nt4LicenseRecord.checkSum.dwSystemBiosChkSum;
LicensedClient.dwVideoBiosChkSum = nt4LicenseRecord.checkSum.dwVideoBiosChkSum;
LicensedClient.dwFloppyBiosChkSum = nt4LicenseRecord.checkSum.dwFloppyBiosChkSum;
LicensedClient.dwHardDiskSize = nt4LicenseRecord.checkSum.dwHardDiskSize;
LicensedClient.dwRamSize = nt4LicenseRecord.checkSum.dwRamSize;
hwidHint = LicensedClient;
LicensedClient.dbLowerBound = hwidHint.dbLowerBound;
//
if(LicensedTable.InsertRecord(LicensedClient) == FALSE)
{
dwStatus = SET_JB_ERROR(LicensedTable.GetLastJetError());
goto cleanup;
}
}
NT4RecordEnumEnd(lpSqlStmt);
if(dwStatus != ERROR_ODBC_NO_DATA_FOUND)
{
// something wrong in fetch().
goto cleanup;
}
dwStatus = ERROR_SUCCESS;
cleanup:
lpSqlStmt->Cleanup();
LicensedTable.CloseTable();
return dwStatus;
}
//--------------------------------------------------------------------------
DWORD
UpgradeLicensePackDescTable(
CSQLStmt* lpSqlStmt,
JBDatabase& jbDatabase
)
/*++
Note:
Transaction must be active
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
NT4KEYPACKDESC nt4KpDesc;
NT4KEYPACKDESCRECORD nt4KpDescRecord(&nt4KpDesc);
LICPACKDESC LicPackDesc;
LicPackDescTable LicPackDescTable(jbDatabase);
BOOL bSuccess;
bSuccess = LicPackDescTable.OpenTable(
TRUE,
JET_bitTableUpdatable
);
if(bSuccess == FALSE)
{
dwStatus = SET_JB_ERROR(LicPackDescTable.GetLastJetError());
SetLastError(dwStatus);
goto cleanup;
}
lpSqlStmt->Cleanup();
dwStatus = NT4KeyPackDescEnumBegin(
lpSqlStmt,
&nt4KpDescRecord
);
if(dwStatus != ERROR_SUCCESS)
goto cleanup;
while( (dwStatus = NT4RecordEnumNext(lpSqlStmt)) == ERROR_SUCCESS )
{
memset(&LicPackDesc, 0, sizeof(LicPackDesc));
LicPackDesc.ucEntryStatus = 0;
LicPackDesc.dwKeyPackId = nt4KpDesc.dwKeyPackId;
LicPackDesc.dwLanguageId = nt4KpDesc.dwLanguageId;
// LicPackDesc.ftLastModifyTime = 0;
SAFESTRCPY(LicPackDesc.szCompanyName, nt4KpDesc.szCompanyName);
SAFESTRCPY(LicPackDesc.szProductName, nt4KpDesc.szProductName);
SAFESTRCPY(LicPackDesc.szProductDesc, nt4KpDesc.szProductDesc);
//
if(LicPackDescTable.InsertRecord(LicPackDesc) == FALSE)
{
dwStatus = SET_JB_ERROR(LicPackDescTable.GetLastJetError());
goto cleanup;
}
}
NT4RecordEnumEnd(lpSqlStmt);
if(dwStatus != ERROR_ODBC_NO_DATA_FOUND)
{
// something wrong in fetch().
goto cleanup;
}
dwStatus = ERROR_SUCCESS;
cleanup:
lpSqlStmt->Cleanup();
LicPackDescTable.CloseTable();
return dwStatus;
}
//--------------------------------------------------------------------------
DWORD
UpgradeLicensePackTable(
CSQLStmt* lpSqlStmt,
JBDatabase& jbDatabase
)
/*++
Note:
Transaction must be active
++*/
{
DWORD dwStatus = ERROR_SUCCESS;
NT4KEYPACK nt4KeyPack;
NT4KEYPACKRECORD nt4KeyPackRecord(&nt4KeyPack);
LICENSEPACK LicPack;
LicPackTable LicPackTable(jbDatabase);
BOOL bSuccess=TRUE;
//FILETIME ftCurTime;
//SYSTEMTIME sysTime;
//GetSystemTime(&sysTime);
//if(SystemTimeToFileTime(&sysTime, &ftCurTime) == FALSE)
//{
// dwStatus = GetLastError();
// goto cleanup;
//}
//
// Open License KeyPack table
//
bSuccess = LicPackTable.OpenTable(
TRUE,
JET_bitTableUpdatable
);
if(bSuccess == FALSE)
{
dwStatus = SET_JB_ERROR(LicPackTable.GetLastJetError());
SetLastError(dwStatus);
goto cleanup;
}
lpSqlStmt->Cleanup();
dwStatus = NT4KeyPackEnumBegin(
lpSqlStmt,
&nt4KeyPackRecord
);
if(dwStatus != ERROR_SUCCESS)
goto cleanup;
while( (dwStatus = NT4RecordEnumNext(lpSqlStmt)) == ERROR_SUCCESS )
{
memset(&LicPack, 0, sizeof(LicPack));
//
// Copy over license pack information.
//
LicPack.ucEntryStatus = 0;
LicPack.dwKeyPackId = nt4KeyPack.dwKeyPackId;
//LicPack.ftLastModifyTime = 0; // don't want this license pack to
// be populated to other server
LicPack.dwAttribute = 0;
if( nt4KeyPack.ucKeyPackType > LSKEYPACKTYPE_LAST ||
nt4KeyPack.ucKeyPackType < LSKEYPACKTYPE_FIRST)
{
//
// This is an invalid key pack, ignore
//
continue;
}
if( nt4KeyPack.ucKeyPackType == LSKEYPACKTYPE_SELECT ||
nt4KeyPack.ucKeyPackType == LSKEYPACKTYPE_TEMPORARY ||
nt4KeyPack.ucKeyPackType == LSKEYPACKTYPE_FREE)
{
LicPack.dwNextSerialNumber = nt4KeyPack.dwNumberOfLicenses + 1;
}
else
{
LicPack.dwNextSerialNumber = nt4KeyPack.dwTotalLicenseInKeyPack - nt4KeyPack.dwNumberOfLicenses + 1;
}
LicPack.dwActivateDate = nt4KeyPack.dwActivateDate;
LicPack.dwExpirationDate = nt4KeyPack.dwExpirationDate;
LicPack.dwNumberOfLicenses = nt4KeyPack.dwNumberOfLicenses;
LicPack.ucKeyPackStatus = nt4KeyPack.ucKeyPackStatus;
LicPack.pbDomainSid = NULL;
LicPack.cbDomainSid = 0;
memcpy(
LicPack.szInstallId,
g_pbSetupId,
min(sizeof(LicPack.szInstallId)/sizeof(LicPack.szInstallId[0]) - 1, g_cbSetupId)
);
// LicPack.szDomainName
SAFESTRCPY(LicPack.szTlsServerName, g_szComputerName);
//
// Standard KeyPack Property..
//
LicPack.ucAgreementType = nt4KeyPack.ucKeyPackType;
SAFESTRCPY(LicPack.szCompanyName, nt4KeyPack.szCompanyName)
SAFESTRCPY(LicPack.szProductId, nt4KeyPack.szProductId);
LicPack.wMajorVersion = nt4KeyPack.wMajorVersion;
LicPack.wMinorVersion = nt4KeyPack.wMinorVersion;
//
// TermSrv specific code
//
if(_tcsicmp(LicPack.szProductId, NT4HYDRAPRODUCT_FULLVERSION_SKU) == 0)
{
LicPack.dwPlatformType = 0xFF;
SAFESTRCPY(LicPack.szKeyPackId, nt4KeyPack.szProductId);
}
else if(_tcsicmp(LicPack.szProductId, NT4HYDRAPRODUCT_UPGRADE_SKU) == 0)
{
LicPack.dwPlatformType = 0x1;
SAFESTRCPY(LicPack.szKeyPackId, nt4KeyPack.szProductId);
}
else if(_tcsicmp(LicPack.szProductId, NT4HYDRAPRODUCT_EXISTING_SKU) == 0)
{
LicPack.dwPlatformType = 0x2;
SAFESTRCPY(LicPack.szKeyPackId, nt4KeyPack.szProductId);
}
else
{
SAFESTRCPY(LicPack.szKeyPackId, nt4KeyPack.szKeyPackId);
LicPack.dwPlatformType = nt4KeyPack.dwPlatformType;
}
LicPack.ucLicenseType = nt4KeyPack.ucLicenseType;
LicPack.ucChannelOfPurchase = nt4KeyPack.ucChannelOfPurchase;
SAFESTRCPY(LicPack.szBeginSerialNumber, nt4KeyPack.szBeginSerialNumber);
LicPack.dwTotalLicenseInKeyPack = nt4KeyPack.dwTotalLicenseInKeyPack;
LicPack.dwProductFlags = nt4KeyPack.dwProductFlags;
//
if(LicPackTable.InsertRecord(LicPack) == FALSE)
{
dwStatus = SET_JB_ERROR(LicPackTable.GetLastJetError());
goto cleanup;
}
}
NT4RecordEnumEnd(lpSqlStmt);
if(dwStatus != ERROR_ODBC_NO_DATA_FOUND)
{
// something wrong in fetch().
goto cleanup;
}
dwStatus = ERROR_SUCCESS;
cleanup:
lpSqlStmt->Cleanup();
LicPackTable.CloseTable();
return dwStatus;
}
#endif
//--------------------------------------------------------------------------
DWORD
GetNT4DbConfig(
LPTSTR pszDsn,
LPTSTR pszUserName,
LPTSTR pszPwd,
LPTSTR pszMdbFile
)
/*++
++*/
{
HKEY hKey = NULL;
DWORD dwStatus = ERROR_SUCCESS;
TCHAR szOdbcDsn[128]=NT4LSERVER_DEFAULT_DSN; // ODBC DSN
TCHAR szOdbcUser[128]=NT4LSERVER_DEFAULT_USER; // ODBC User Name
TCHAR szOdbcPwd[128]=NT4LSERVER_DEFAULT_PWD; // ODBC Password
TCHAR szMdbFile[MAX_PATH+1];
DWORD dwBuffer=0;
PBYTE pbData = NULL;
DWORD cbData = 0;
BOOL bSuccess;
//
// Open NT4 license server specific registry key
//
dwStatus = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
NT4LSERVER_REGKEY,
0,
KEY_ALL_ACCESS,
&hKey
);
if(dwStatus != ERROR_SUCCESS)
{
dwStatus = ERROR_INVALID_NT4_SETUP;
goto cleanup;
}
//
// Load ODBC DSN and User name from registry,
// ignore error return and use default value.
//
dwBuffer = sizeof(szOdbcDsn);
dwStatus = RegQueryValueEx(
hKey,
NT4LSERVER_PARAMETERS_DSN,
NULL,
NULL,
(LPBYTE)szOdbcDsn,
&dwBuffer
);
if(dwStatus == ERROR_SUCCESS && pszDsn)
{
lstrcpy(pszDsn, szOdbcDsn);
}
dwBuffer = sizeof(szOdbcUser);
dwStatus = RegQueryValueEx(
hKey,
NT4LSERVER_PARAMETERS_USER,
NULL,
NULL,
(LPBYTE)szOdbcUser,
&dwBuffer
);
if(dwStatus == ERROR_SUCCESS && pszUserName)
{
lstrcpy(pszUserName, szOdbcUser);
}
//
// Load database password from LSA
//
dwStatus = RetrieveKey(
LSERVER_LSA_PASSWORD_KEYNAME,
&pbData,
&cbData
);
#ifndef PRIVATE_DBG
if(dwStatus != ERROR_SUCCESS)
{
//
// Invalid NT4 license server setup or hydra beta2
// license server which we don't support.
//
dwStatus = ERROR_INVALID_NT4_SETUP;
goto cleanup;
}
#endif
dwStatus = ERROR_SUCCESS;
memset(szOdbcPwd, 0, sizeof(szOdbcPwd));
memcpy(
(PBYTE)szOdbcPwd,
pbData,
min(cbData, sizeof(szOdbcPwd) - sizeof(TCHAR))
);
if(pszPwd != NULL)
{
lstrcpy(pszPwd, szOdbcPwd);
}
//
// Verify data source is properly installed
//
bSuccess = IsDataSourceInstalled(
szOdbcDsn,
ODBC_SYSTEM_DSN,
szMdbFile,
MAX_PATH
);
if(bSuccess == FALSE)
{
dwStatus = ERROR_INVALID_NT4_SETUP;
goto cleanup;
}
if(pszMdbFile != NULL)
{
_tcscpy(pszMdbFile, szMdbFile);
}
cleanup:
if(hKey != NULL)
{
RegCloseKey(hKey);
}
if(pbData != NULL)
{
LocalFree(pbData);
}
return dwStatus;
}
//--------------------------------------------------------------------------
DWORD
DeleteNT4ODBCDataSource()
/*++
--*/
{
BOOL bSuccess;
DWORD dwStatus = ERROR_SUCCESS;
//
// Get Hydra 4 DB configuration, make sure
// data source is properly config.
//
dwStatus = GetNT4DbConfig(
g_szOdbcDsn,
g_szOdbcUser,
g_szOdbcPwd,
g_szMdbFile
);
if(dwStatus == ERROR_SUCCESS)
{
bSuccess = ConfigDataSource(
NULL,
FALSE,
_TEXT(SZACCESSDRIVERNAME),
g_szOdbcDsn,
g_szOdbcUser,
g_szOdbcPwd,
g_szMdbFile
);
if(bSuccess == FALSE)
{
dwStatus = ERROR_DELETE_ODBC_DSN;
}
}
return dwStatus;
}
//--------------------------------------------------------------------------
#ifndef LICENOC_SMALL_UPG
DWORD
UpgradeNT4Database(
IN DWORD dwServerRole,
IN LPCTSTR pszDbFilePath,
IN LPCTSTR pszDbFileName,
IN BOOL bAlwaysDeleteDataSource
)
/*++
Abstract:
This routine is to upgrade Hydra4 Terminal Licensing Server database to
NT5. Hydra4 uses ODBC/Jet while NT5 uses JetBlue as database engine,
other changes includes table structure and additional table.
Parameters:
dwServerRole - Server role in enterprise, 0 - ordinaly server, 1 - enterprise server
pszDbFilePath - Directory for NT5 Terminal Licensing Server Database. License
Server uses this directory as JetBlue instance's log/temp/system path.
pszDbFileName - Database file name, default to TlsLic.edb if NULL.
Returns:
ERROR_SUCCESS or error code, see upg.h for list of error code and description
++*/
{
DWORD dwStatus=ERROR_SUCCESS;
TCHAR szFileName[MAX_PATH+1];
CSQLStmt sqlStmt;
UUID uuid;
unsigned short *szUuid=NULL;
BOOL bSuccess;
DWORD dwNt4DbVersion;
DWORD dwComputerName = sizeof(g_szComputerName)/sizeof(g_szComputerName[0]);
BOOL bNT4LserverExists = FALSE;
memset(g_szComputerName, 0, sizeof(g_szComputerName));
GetComputerName(g_szComputerName, &dwComputerName);
//
// Verify input parameter. pszDbFilePath must not have '\' as last
// character.
//
if(pszDbFilePath == NULL || *pszDbFilePath == _TEXT('0'))
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
goto cleanup;
}
if(pszDbFilePath[_tcslen(pszDbFilePath) - 1] == _TEXT('\\'))
{
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
goto cleanup;
}
//
// Make sure target directory exist.
//
if(FileExists(pszDbFilePath, NULL) == FALSE)
{
dwStatus = ERROR_TARGETFILE_NOT_FOUND;
goto cleanup;
}
//
// Database file can't exist, we have no idea what it is.
//
wsprintf(
szFileName,
_TEXT("%s\\%s"),
pszDbFilePath,
(pszDbFileName) ? pszDbFileName : LSERVER_DEFAULT_EDB
);
//
// Verify File does not exist, this file might
// not be a valid JetBlue database file, setup
// should verify and prompt user for different
// file name
//
if(FileExists(szFileName, NULL) == TRUE)
{
dwStatus = ERROR_DEST_FILE_EXIST;
goto cleanup;
}
//
// Get Hydra 4 DB configuration, make sure
// data source is properly config.
//
dwStatus = GetNT4DbConfig(
g_szOdbcDsn,
g_szOdbcUser,
g_szOdbcPwd,
g_szMdbFile
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
bNT4LserverExists = TRUE;
//
// Generate License Server Setup Id
//
dwStatus = RetrieveKey(
LSERVER_LSA_SETUPID,
&g_pbSetupId,
&g_cbSetupId
);
#ifndef PRIVATE_DBG
if(dwStatus == ERROR_SUCCESS)
{
//
// NT4 Hydra does not use this setup ID.
//
dwStatus = ERROR_INVALID_NT4_SETUP;
goto cleanup;
}
#endif
//
// Generate License Server Unique Setup ID
//
UuidCreate(&uuid);
UuidToString(&uuid, &szUuid);
g_pbSetupId = (PBYTE)AllocateMemory((_tcslen(szUuid)+1)*sizeof(TCHAR));
if(g_pbSetupId == NULL)
{
dwStatus = GetLastError();
goto cleanup;
}
memcpy(
g_pbSetupId,
szUuid,
(_tcslen(szUuid) + 1)*sizeof(TCHAR)
);
g_cbSetupId = (_tcslen(szUuid) + 1)*sizeof(TCHAR);
RpcStringFree(&szUuid);
szUuid = NULL;
//
// Open one SQL handle to Hydra data source
//
dwStatus = OpenSqlStmtHandle(
&sqlStmt,
g_szOdbcDsn,
g_szOdbcUser,
g_szOdbcPwd,
g_szMdbFile
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
//
// Verify this is latest Hydra 4
//
dwStatus = GetNt4DatabaseVersion(
&sqlStmt,
(LONG *)&dwNt4DbVersion
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
if(dwNt4DbVersion != HYDRA_DATABASE_NT40_VERSION)
{
//
// Only support release database version
//
dwStatus = ERROR_NOTSUPPORT_DB_VERSION;
goto cleanup;
}
//
// Initialize JetBlue and create an empty database
//
dwStatus = JetBlueInitAndCreateEmptyDatabase(
pszDbFilePath,
(pszDbFileName) ? pszDbFileName : LSERVER_DEFAULT_EDB,
g_szOdbcUser,
g_szOdbcPwd,
g_JbInstance,
g_JetSession,
g_JetDatabase
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
//
// Begin JetBlue Transaction,
// JetBlue Transaction is session based.
//
g_JetSession.BeginTransaction();
//
// Copy over licensed key pack table
//
dwStatus = UpgradeLicensePackTable(
&sqlStmt,
g_JetDatabase
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
//
// Copy over licensed key pack desc. table
//
dwStatus = UpgradeLicensePackDescTable(
&sqlStmt,
g_JetDatabase
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
//
// Copy over issued license table
//
dwStatus = UpgradeIssuedLicenseTable(
&sqlStmt,
g_JetDatabase
);
if(dwStatus != ERROR_SUCCESS)
{
goto cleanup;
}
//
// Write License Server Setup ID to LSA
//
dwStatus = StoreKey(
LSERVER_LSA_SETUPID,
g_pbSetupId,
g_cbSetupId
);
//
// TODO : if we could not write setup ID to LSA
//
cleanup:
if(dwStatus == ERROR_SUCCESS)
{
g_JetSession.CommitTransaction();
}
else
{
g_JetSession.RollbackTransaction();
}
//
// Close ODBC handle
//
sqlStmt.Close();
CSQLStmt::Shutdown();
g_JetDatabase.CloseDatabase();
g_JetSession.EndSession();
if(dwStatus != ERROR_SUCCESS)
{
//
// Reset last run status, password is not use on JetBlue,
// LSERVER_LSA_SETUPID will not get setup if error.
//
TLServerLastRunState lastRun;
memset(&lastRun, 0, sizeof(TLServerLastRunState));
lastRun.dwVersion = LSERVER_LSA_STRUCT_VERSION;
StoreKey(
LSERVER_LSA_LASTRUN,
(PBYTE)&lastRun,
sizeof(TLServerLastRunState)
);
}
if( (dwStatus == ERROR_SUCCESS) ||
(bAlwaysDeleteDataSource == TRUE && bNT4LserverExists == TRUE) )
{
//
// Remove "Hydra License" from data source.
// Non-critical error if we can't remove data source.
//
ConfigDataSource(
NULL,
FALSE,
_TEXT(SZACCESSDRIVERNAME),
g_szOdbcDsn,
g_szOdbcUser,
g_szOdbcPwd,
g_szMdbFile
);
}
FreeMemory(g_pbSetupId);
return dwStatus;
}
#endif
//---------------------------------------------------
//
// License Server secret key info.
//
#define LSERVER_LSA_PRIVATEKEY_SIGNATURE _TEXT("TermServLiceningSignKey-12d4b7c8-77d5-11d1-8c24-00c04fa3080d")
#define LSERVER_LSA_PRIVATEKEY_EXCHANGE _TEXT("TermServLicensingExchKey-12d4b7c8-77d5-11d1-8c24-00c04fa3080d")
#define LSERVER_LSA_LSERVERID _TEXT("TermServLicensingServerId-12d4b7c8-77d5-11d1-8c24-00c04fa3080d")
#define LSERVER_SOFTWARE_REGBASE \
_TEXT("SOFTWARE\\Microsoft\\") _TEXT(SZSERVICENAME)
#define LSERVER_CERTIFICATE_STORE _TEXT("Certificates")
#define LSERVER_SELFSIGN_CERTIFICATE_REGKEY \
LSERVER_REGISTRY_BASE _TEXT(SZSERVICENAME) _TEXT("\\") LSERVER_SECRET
#define LSERVER_SERVER_CERTIFICATE_REGKEY \
LSERVER_SOFTWARE_REGBASE _TEXT("\\") LSERVER_CERTIFICATE_STORE
#define LSERVER_CLIENT_CERTIFICATE_ISSUER _TEXT("Parm0")
#define LSERVER_SIGNATURE_CERT_KEY _TEXT("Parm1")
#define LSERVER_EXCHANGE_CERT_KEY _TEXT("Parm2")
void
CleanLicenseServerSecret()
/*++
--*/
{
DWORD dwStatus = ERROR_SUCCESS;
HKEY hKey = NULL;
//
// Wipe out SPK in LSA
//
dwStatus = StoreKey(
LSERVER_LSA_LSERVERID,
(PBYTE) NULL,
0
);
dwStatus = StoreKey(
LSERVER_LSA_LASTRUN,
(PBYTE) NULL,
0
);
dwStatus = StoreKey(
LSERVER_LSA_PRIVATEKEY_EXCHANGE,
(PBYTE) NULL,
0
);
dwStatus = StoreKey(
LSERVER_LSA_PRIVATEKEY_SIGNATURE,
(PBYTE) NULL,
0
);
dwStatus=RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
LSERVER_SERVER_CERTIFICATE_REGKEY,
0,
KEY_ALL_ACCESS,
&hKey
);
if(dwStatus == ERROR_SUCCESS)
{
//
// Ignore error
RegDeleteValue(
hKey,
LSERVER_SIGNATURE_CERT_KEY
);
RegDeleteValue(
hKey,
LSERVER_EXCHANGE_CERT_KEY
);
RegDeleteValue(
hKey,
LSERVER_CLIENT_CERTIFICATE_ISSUER
);
}
if(hKey != NULL)
{
RegCloseKey(hKey);
}
return;
}