windows-nt/Source/XPSP1/NT/termsrv/license/tlserver/debug/tsctst/tsctst.cpp

288 lines
8.5 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
#include <windows.h>
#include <shellapi.h>
#include <stdio.h>
#include <tchar.h>
#include <stdlib.h>
#include <rpc.h>
#include <time.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <crt/io.h>
#include <wincrypt.h>
#include "license.h"
#include "certutil.h"
BYTE g_pSecretKey[1024];
DWORD g_cbSecretKey=sizeof(g_pSecretKey);
#define SAFESTRCPY(dest, source) \
_tcsncpy(dest, source, min(_tcslen(source), sizeof(dest) - sizeof(TCHAR)))
#define COMMON_STORE TEXT("Software\\Microsoft\\MSLicensing\\Store")
#define LICENSE_VAL TEXT("ClientLicense")
LPCSTR
FileTimeText(
FILETIME *pft )
{
static char buf[80];
FILETIME ftLocal;
struct tm ctm;
SYSTEMTIME st;
FileTimeToLocalFileTime( pft, &ftLocal );
if( FileTimeToSystemTime( &ftLocal, &st ) )
{
ctm.tm_sec = st.wSecond;
ctm.tm_min = st.wMinute;
ctm.tm_hour = st.wHour;
ctm.tm_mday = st.wDay;
ctm.tm_mon = st.wMonth-1;
ctm.tm_year = st.wYear-1900;
ctm.tm_wday = st.wDayOfWeek;
ctm.tm_yday = 0;
ctm.tm_isdst = 0;
strcpy(buf, asctime(&ctm));
buf[strlen(buf)-1] = 0;
}
else
{
sprintf( buf,
"<FILETIME %08lX:%08lX>",
pft->dwHighDateTime,
pft->dwLowDateTime );
}
return buf;
}
void MyReportError(DWORD errCode)
{
DWORD dwRet;
LPTSTR lpszTemp = NULL;
dwRet=FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
errCode,
LANG_NEUTRAL,
(LPTSTR)&lpszTemp,
0,
NULL);
if(dwRet != 0)
{
_tprintf(_TEXT("Error : %s (%d)\n"), lpszTemp, errCode);
if(lpszTemp)
LocalFree((HLOCAL)lpszTemp);
}
return;
}
//------------------------------------------------------------------------------------------
void DumpLicensedProduct(PLICENSEDPRODUCT pLicensedInfo)
{
_tprintf(_TEXT("Version - 0x%08x\n"), pLicensedInfo->dwLicenseVersion);
_tprintf(_TEXT("Quantity - %d\n"), pLicensedInfo->dwQuantity);
_tprintf(_TEXT("Issuer - %s\n"), pLicensedInfo->szIssuer);
_tprintf(_TEXT("Scope - %s\n"), pLicensedInfo->szIssuerScope);
if(pLicensedInfo->szLicensedClient)
_tprintf(_TEXT("Issued to machine - %s\n"), pLicensedInfo->szLicensedClient);
if(pLicensedInfo->szLicensedUser)
_tprintf(_TEXT("Issued to user - %s\n"), pLicensedInfo->szLicensedUser);
_tprintf(_TEXT("Licensed Product\n"));
_tprintf(_TEXT("\tHWID - 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x\n"),
pLicensedInfo->Hwid.dwPlatformID,
pLicensedInfo->Hwid.Data1,
pLicensedInfo->Hwid.Data2,
pLicensedInfo->Hwid.Data3,
pLicensedInfo->Hwid.Data4);
_tprintf(_TEXT("\tlanguage ID - 0x%08x\n"), pLicensedInfo->LicensedProduct.dwLanguageID);
_tprintf(_TEXT("\tPlatform ID - 0x%08x\n"), pLicensedInfo->LicensedProduct.dwPlatformID);
_tprintf(_TEXT("\tProduct Version - 0x%08x\n"), pLicensedInfo->LicensedProduct.pProductInfo->dwVersion);
_tprintf(_TEXT("\tCompany Name - %s\n"), pLicensedInfo->LicensedProduct.pProductInfo->pbCompanyName);
_tprintf(_TEXT("\tProduct ID - %s\n"), pLicensedInfo->LicensedProduct.pProductInfo->pbProductID);
for(DWORD i=0; i < pLicensedInfo->dwNumLicensedVersion; i++)
{
_tprintf(_TEXT("Licensed Product Version %04d.%04d, Flag 0x%08x\n"),
pLicensedInfo->pLicensedVersion[i].wMajorVersion,
pLicensedInfo->pLicensedVersion[i].wMinorVersion,
pLicensedInfo->pLicensedVersion[i].dwFlags);
if (pLicensedInfo->pLicensedVersion[i].dwFlags & LICENSED_VERSION_TEMPORARY)
{
_tprintf(_TEXT("Temporary\t"));
}
else
{
_tprintf(_TEXT("Permanent\t"));
}
if (pLicensedInfo->pLicensedVersion[i].dwFlags & LICENSED_VERSION_RTM)
{
_tprintf(_TEXT("RTM\t"));
}
else
{
_tprintf(_TEXT("Beta\t"));
}
_tprintf(_TEXT("\n"));
}
printf("Not Before - %x %x %s\n",
pLicensedInfo->NotBefore.dwHighDateTime,
pLicensedInfo->NotBefore.dwLowDateTime,
FileTimeText(&pLicensedInfo->NotBefore));
printf("Not After - %x %x %s\n",
pLicensedInfo->NotAfter.dwHighDateTime,
pLicensedInfo->NotAfter.dwLowDateTime,
FileTimeText(&pLicensedInfo->NotAfter));
}
int __cdecl main(int argc, char *argv[])
{
HKEY hKey, hKeyStore;
LPBYTE lpKeyValue=NULL;
DWORD cbKeyValue;
DWORD dwStatus;
DWORD dwKeyType;
TCHAR lpName[128];
DWORD cName;
FILETIME ftWrite;
LICENSEDPRODUCT LicensedInfo[10];
DWORD dwNum;
ULARGE_INTEGER SerialNumber;
BYTE pbKey[1024];
DWORD cbKey=1024;
LICENSE_STATUS lstatus;
dwStatus=RegOpenKeyEx(HKEY_LOCAL_MACHINE,
COMMON_STORE,
0,
KEY_READ,
&hKey);
if(dwStatus != ERROR_SUCCESS)
{
_tprintf(_TEXT("Can't open key - %ld\n"), dwStatus);
return 0;
}
LSInitCertutilLib( 0 );
LicenseGetSecretKey( &cbKey, pbKey );
for (DWORD dwKey = 0; dwStatus == ERROR_SUCCESS; dwKey++)
{
cName = sizeof(lpName) / sizeof(TCHAR);
dwStatus=RegEnumKeyEx(hKey,
dwKey,
lpName,
&cName,
NULL,
NULL,
NULL,
&ftWrite);
if (ERROR_SUCCESS == dwStatus)
{
dwStatus = RegOpenKeyEx(hKey,
lpName,
0,
KEY_READ,
&hKeyStore);
if(dwStatus != ERROR_SUCCESS)
{
_tprintf(_TEXT("can't open store - %d\n"), dwStatus);
goto cleanup;
}
cbKeyValue=0;
dwStatus = RegQueryValueEx(hKeyStore,
LICENSE_VAL,
NULL,
&dwKeyType,
NULL,
&cbKeyValue);
if(dwStatus != ERROR_SUCCESS)
{
_tprintf(_TEXT("can't get value size - %d\n"), dwStatus);
RegCloseKey(hKeyStore);
goto cleanup;
}
lpKeyValue = (LPBYTE)malloc(cbKeyValue);
if(!lpKeyValue)
{
_tprintf(_TEXT("Can't allocate %d bytes\n"), cbKeyValue);
RegCloseKey(hKeyStore);
goto cleanup;
}
dwStatus = RegQueryValueEx(hKeyStore,
LICENSE_VAL,
NULL,
&dwKeyType,
lpKeyValue,
&cbKeyValue);
if(dwStatus != ERROR_SUCCESS)
{
_tprintf(_TEXT("can't get value - %d\n"), dwStatus);
free(lpKeyValue);
RegCloseKey(hKeyStore);
goto cleanup;
}
memset(LicensedInfo, 0, sizeof(LicensedInfo));
dwNum = 10;
lstatus = LSVerifyDecodeClientLicense(lpKeyValue, cbKeyValue, pbKey, cbKey, &dwNum, LicensedInfo);
if (lstatus == LICENSE_STATUS_OK)
{
for (DWORD i = 0; i < dwNum; i++)
{
_tprintf(_TEXT("\n*** License # %d ***\n"), i+1);
DumpLicensedProduct(LicensedInfo+i);
}
LSFreeLicensedProduct(LicensedInfo);
}
else
{
_tprintf(_TEXT("can't decode license - %d, %d\n"), lstatus, GetLastError());
free(lpKeyValue);
RegCloseKey(hKeyStore);
goto cleanup;
}
free(lpKeyValue);
RegCloseKey(hKeyStore);
_tprintf(_TEXT("\n\n"));
}
}
cleanup:
RegCloseKey(hKey);
LSShutdownCertutilLib();
return 0;
}