able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dxg/d3d8/fw/drvinfo.c

1182 lines
37 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*==========================================================================;
*
* Copyright (C) 1994-1997 Microsoft Corporation. All Rights Reserved.
*
* File: drvinfo.c
* Content: DirectDraw driver info implementation
*@@BEGIN_MSINTERNAL
* History:
* Date By Reason
* ==== == ======
* 17-jun-98 jeffno initial implementation, after michael lyons and toddla
* 14-jun-99 mregen return WHQL certification level -- postponed
*@@END_MSINTERNAL
*
***************************************************************************/
#include "ddrawpr.h"
#include <tchar.h>
#include <stdio.h>
#include <wincrypt.h>
#include <wintrust.h>
#include <softpub.h>
#include <mscat.h>
//========================================================================
//
// just some handy forward declarations
//
DWORD GetWHQLLevel(LPTSTR lpszDriver, LPSTR lpszWin9xDriver);
DWORD IsFileDigitallySigned(LPTSTR lpszDriver);
BOOL FileIsSignedOld(LPTSTR lpszFile);
//
// These functions are defined in mscat.h. They are not available on win95,
// so we have to use LoadLibrary to load mscat32.dll and wincrypt.dll
//
typedef HCATINFO WINAPI funcCryptCATAdminEnumCatalogFromHash(HCATADMIN hCatAdmin,
BYTE *pbHash,
DWORD cbHash,
DWORD dwFlags,
HCATINFO *phPrevCatInfo);
typedef BOOL WINAPI funcCryptCATAdminCalcHashFromFileHandle(HANDLE hFile,
DWORD *pcbHash,
BYTE *pbHash,
DWORD dwFlags);
typedef HANDLE WINAPI funcCryptCATOpen(LPWSTR pwszFileName,
DWORD fdwOpenFlags,
HCRYPTPROV hProv,
DWORD dwPublicVersion,
DWORD dwEncodingType);
typedef BOOL WINAPI funcCryptCATClose(IN HANDLE hCatalog);
typedef CRYPTCATATTRIBUTE * WINAPI funcCryptCATGetCatAttrInfo(HANDLE hCatalog,
LPWSTR pwszReferenceTag);
typedef BOOL WINAPI funcCryptCATAdminAcquireContext(HCATADMIN *phCatAdmin,
GUID *pgSubsystem,
DWORD dwFlags);
typedef BOOL WINAPI funcCryptCATAdminReleaseContext(HCATADMIN hCatAdmin,
DWORD dwFlags);
typedef BOOL WINAPI funcCryptCATAdminReleaseCatalogContext(HCATADMIN hCatAdmin,
HCATINFO hCatInfo,
DWORD dwFlags);
typedef BOOL WINAPI funcCryptCATCatalogInfoFromContext(HCATINFO hCatInfo,
CATALOG_INFO *psCatInfo,
DWORD dwFlags);
typedef CRYPTCATATTRIBUTE * WINAPI funcCryptCATEnumerateCatAttr(HCATINFO hCatalog,
CRYPTCATATTRIBUTE *lpCat);
//
// function defined in wincrypt.dll
//
typedef LONG WINAPI funcWinVerifyTrust(HWND hwnd, GUID *pgActionID,
LPVOID pWVTData);
//
// our storage for the mscat32/wincrypt dll loader
//
typedef struct tagCatApi {
BOOL bInitialized;
HINSTANCE hLibMSCat;
HINSTANCE hLibWinTrust;
HCATADMIN hCatAdmin;
funcCryptCATClose *pCryptCATClose;
funcCryptCATGetCatAttrInfo *pCryptCATGetCatAttrInfo;
funcCryptCATOpen *pCryptCATOpen;
funcCryptCATAdminEnumCatalogFromHash *pCryptCATAdminEnumCatalogFromHash;
funcCryptCATAdminCalcHashFromFileHandle *pCryptCATAdminCalcHashFromFileHandle;
funcCryptCATAdminAcquireContext *pCryptCATAdminAcquireContext;
funcCryptCATAdminReleaseContext *pCryptCATAdminReleaseContext;
funcCryptCATAdminReleaseCatalogContext *pCryptCATAdminReleaseCatalogContext;
funcCryptCATCatalogInfoFromContext *pCryptCATCatalogInfoFromContext;
funcCryptCATEnumerateCatAttr *pCryptCATEnumerateCatAttr;
funcWinVerifyTrust *pWinVerifyTrust;
} CATAPI,* LPCATAPI;
//========================================================================
//
// some helper functions to open/close crypt API
//
#undef DPF_MODNAME
#define DPF_MODNAME "InitCATAPI"
BOOL InitCATAPI(LPCATAPI lpCatApi)
{
UINT uiOldErrorMode;
HINSTANCE hLibMSCat;
HINSTANCE hLibWinTrust;
DDASSERT(lpCatApi!=NULL);
ZeroMemory(lpCatApi, sizeof(CATAPI));
// already initialized by ZeroMemory
// lpCatApi->bInitialized=FALSE:
uiOldErrorMode=SetErrorMode(SEM_NOOPENFILEERRORBOX);
hLibMSCat=LoadLibrary("mscat32.dll");
hLibWinTrust=LoadLibrary("wintrust.dll");
if (hLibMSCat!=NULL &&
hLibWinTrust!=NULL)
{
lpCatApi->pCryptCATOpen=(funcCryptCATOpen *)
GetProcAddress (hLibMSCat, "CryptCATOpen");
lpCatApi->pCryptCATClose=(funcCryptCATClose *)
GetProcAddress (hLibMSCat, "CryptCATClose");
lpCatApi->pCryptCATGetCatAttrInfo=(funcCryptCATGetCatAttrInfo *)
GetProcAddress (hLibMSCat, "CryptCATGetCatAttrInfo");
lpCatApi->pCryptCATAdminCalcHashFromFileHandle=(funcCryptCATAdminCalcHashFromFileHandle*)
GetProcAddress (hLibMSCat, "CryptCATAdminCalcHashFromFileHandle");
lpCatApi->pCryptCATAdminEnumCatalogFromHash=(funcCryptCATAdminEnumCatalogFromHash*)
GetProcAddress (hLibMSCat, "CryptCATAdminEnumCatalogFromHash");
lpCatApi->pCryptCATAdminAcquireContext=(funcCryptCATAdminAcquireContext*)
GetProcAddress (hLibMSCat, "CryptCATAdminAcquireContext");
lpCatApi->pCryptCATAdminReleaseContext=(funcCryptCATAdminReleaseContext*)
GetProcAddress (hLibMSCat, "CryptCATAdminReleaseContext");
lpCatApi->pCryptCATAdminReleaseCatalogContext=(funcCryptCATAdminReleaseCatalogContext*)
GetProcAddress (hLibMSCat, "CryptCATAdminReleaseCatalogContext");
lpCatApi->pCryptCATCatalogInfoFromContext=(funcCryptCATCatalogInfoFromContext*)
GetProcAddress (hLibMSCat, "CryptCATCatalogInfoFromContext");
lpCatApi->pCryptCATEnumerateCatAttr=(funcCryptCATEnumerateCatAttr*)
GetProcAddress (hLibMSCat, "CryptCATEnumerateCatAttr");
lpCatApi->pWinVerifyTrust=(funcWinVerifyTrust*)
GetProcAddress (hLibWinTrust,"WinVerifyTrust");
if (lpCatApi->pCryptCATOpen!=NULL &&
lpCatApi->pCryptCATClose!=NULL &&
lpCatApi->pCryptCATGetCatAttrInfo!=NULL &&
lpCatApi->pCryptCATAdminCalcHashFromFileHandle!=NULL &&
lpCatApi->pCryptCATAdminEnumCatalogFromHash!=NULL &&
lpCatApi->pCryptCATAdminAcquireContext!=NULL &&
lpCatApi->pCryptCATAdminReleaseContext!=NULL &&
lpCatApi->pCryptCATAdminReleaseCatalogContext!=NULL &&
lpCatApi->pCryptCATCatalogInfoFromContext!=NULL &&
lpCatApi->pCryptCATEnumerateCatAttr !=NULL &&
lpCatApi->pWinVerifyTrust!=NULL
)
{
if ((*lpCatApi->pCryptCATAdminAcquireContext)(&lpCatApi->hCatAdmin,NULL,0))
{
lpCatApi->hLibMSCat=hLibMSCat;
lpCatApi->hLibWinTrust=hLibWinTrust;
lpCatApi->bInitialized=TRUE;
}
}
}
if (!lpCatApi->bInitialized)
{
FreeLibrary(hLibMSCat);
FreeLibrary(hLibWinTrust);
}
SetErrorMode(uiOldErrorMode);
return lpCatApi->bInitialized;
}
BOOL ReleaseCATAPI(LPCATAPI lpCatApi)
{
DDASSERT(lpCatApi!=NULL);
if (lpCatApi->bInitialized)
{
(*lpCatApi->pCryptCATAdminReleaseContext)(lpCatApi->hCatAdmin, 0);
FreeLibrary(lpCatApi->hLibMSCat);
FreeLibrary(lpCatApi->hLibWinTrust);
ZeroMemory(lpCatApi, sizeof(CATAPI));
return TRUE;
}
return FALSE;
}
//========================================================================
//
// _strstr
//
// String-in-string function, written to avoid RTL inclusion necessity.
//
//========================================================================
char *_strstr(char *s1, char *s2)
{
if (s1 && s2)
{
while (*s1)
{
char *p1=s1;
char *p2=s2;
while (*p2 && (*p1==*p2))
{
p1++;
p2++;
}
if (*p2==0)
return s1;
s1++;
}
}
return NULL;
}
//***&&*%**!!ing c runtime
DWORD _atoi(char * p)
{
DWORD dw=0;
while ((*p >= '0' && *p <= '9') || (*p >= 'A' && *p <= 'F') || (*p >= 'A' && *p <= 'F'))
{
dw = dw*16;
if (*p >= 'a')
dw += *p-'a' + 10;
else if (*p >= 'A')
dw += *p-'A' + 10;
else
dw += *p-'0';
p++;
}
return dw;
}
char *FindLast(char * s, char c)
{
char * pFound=0;
if (s)
{
while (*s)
{
if (*s == c)
pFound = s;
s++;
}
}
return pFound;
}
//========================================================================
// hard-coded vendor IDs
//========================================================================
#define VEN_3DFX "VEN_121A"
#define VEN_3DFXVOODOO1 "VEN_121A&DEV_0001"
#define VEN_POWERVR "VEN_1033"
#ifdef WIN95
void GetFileVersionData (D3DADAPTER_IDENTIFIER8* pDI)
{
void * buffer;
VS_FIXEDFILEINFO * verinfo;
DWORD dwSize;
DWORD dwHi,dwLo;
//Failure means 0 returned
pDI->DriverVersion.HighPart = 0;
pDI->DriverVersion.LowPart = 0;
dwSize = GetFileVersionInfoSize (pDI->Driver, 0);
if (!dwSize)
{
return;
}
buffer=MemAlloc(dwSize);
if (!buffer)
{
return;
}
if (!GetFileVersionInfo(pDI->Driver, 0, dwSize, buffer))
{
MemFree(buffer);
return;
}
if (!VerQueryValue(buffer, "\\", (void **)&verinfo, (UINT *)&dwSize))
{
MemFree(buffer);
return;
}
pDI->DriverVersion.HighPart = verinfo->dwFileVersionMS;
pDI->DriverVersion.LowPart = verinfo->dwFileVersionLS;
MemFree(buffer);
}
extern HRESULT _GetDriverInfoFromRegistry(char *szClass, char *szClassNot, char *szVendor, D3DADAPTER_IDENTIFIER8* pDI, char *szDeviceID);
/*
* following are all the 9x-specific version functions
*/
void GetHALName(char* pDriverName, D3DADAPTER_IDENTIFIER8* pDI)
{
pDI->Driver[0] = '\0';
D3D8GetHALName(pDriverName, pDI->Driver);
}
BOOL CheckPowerVR(D3DADAPTER_IDENTIFIER8* pDI)
{
#if 0
BOOL bFound=FALSE;
HKEY hKey;
DWORD dwSize;
DWORD dwType;
if (pdrv->dwFlags & DDRAWI_SECONDARYDRIVERLOADED)
{
/*
* Any secondary driver information in the registry at all? (assert this is true)
*/
if (ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE,
REGSTR_PATH_SECONDARY,
&hKey))
{
/*
* Extract the name of the secondary driver's DLL. (assert this works)
*/
dwSize = sizeof(pDI->di.szDriver) - 1;
if (ERROR_SUCCESS == RegQueryValueEx(hKey,
REGSTR_VALUE_SECONDARY_DRIVERNAME,
NULL,
&dwType,
pDI->di.szDriver,
&dwSize))
{
if (REG_SZ == dwType)
{
GetFileVersionData(pDI);
}
}
RegCloseKey(hKey);
}
if (SUCCEEDED(_GetDriverInfoFromRegistry(NULL, "Display", VEN_POWERVR, pDI)))
{
//got PVR data...
bFound = TRUE;
}
}
return bFound;
#endif
return TRUE;
}
HRESULT Check3Dfx (D3DADAPTER_IDENTIFIER8* pDI)
{
HRESULT hr = S_OK;
char szDeviceID[MAX_DDDEVICEID_STRING];
if (FAILED(_GetDriverInfoFromRegistry(NULL, "Display", VEN_3DFX, pDI, szDeviceID)))
{
DPF_ERR("Couldn't get registry data for this device");
hr = E_FAIL;
}
return hr;
}
HRESULT GetDriverInfoFromRegistry(char *szClass, char *szClassNot, char *szVendor, D3DADAPTER_IDENTIFIER8* pDI, char *szDeviceID)
{
return _GetDriverInfoFromRegistry(szClass, szClassNot, szVendor, pDI, szDeviceID);
}
/*
* Given a DISPLAY_DEVICE, get driver name
* NOTE::: THIS FUNCTION NUKES THE DISPLAY_DEVICE.DeviceKey STRING!!!!
*/
void GetWin9XDriverName(DISPLAY_DEVICEA * pdd, LPSTR pDrvName)
{
HKEY hKey;
lstrcat(pdd->DeviceKey, "\\DEFAULT");
if (ERROR_SUCCESS == RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
pdd->DeviceKey,
0,
KEY_QUERY_VALUE ,
&hKey))
{
DWORD dwSize = MAX_DDDEVICEID_STRING;
DWORD dwType = 0;
RegQueryValueEx(hKey,
TEXT("drv"),
NULL,
&dwType,
pDrvName,
&dwSize);
RegCloseKey(hKey);
}
}
#else //win95
HRESULT Check3Dfx(D3DADAPTER_IDENTIFIER8* pDI)
{
return E_FAIL;
}
HRESULT GetDriverInfoFromRegistry(char *szClass, char *szClassNot, char *szVendor, D3DADAPTER_IDENTIFIER8* pDI, char *szDeviceID)
{
return E_FAIL;
}
/*
* Given a DISPLAY_DEVICE, get driver name, assuming winnt5
* NOTE::: THIS FUNCTION NUKES THE DISPLAY_DEVICE.DeviceKey STRING!!!!
*/
void GetNTDriverNameAndVersion(DISPLAY_DEVICEA * pdd, D3DADAPTER_IDENTIFIER8* pDI)
{
HKEY hKey;
void* buffer;
DWORD dwSize;
VS_FIXEDFILEINFO* verinfo;
//
// old style to determine display driver...returns name of miniport!
//
char * pTemp;
// The device key has the form blah\blah\services\<devicekey>\DeviceN
// So we back up one node:
if ((pTemp = FindLast(pdd->DeviceKey,'\\')))
{
char * pTempX;
char cOld=*pTemp;
*pTemp = 0;
//If we back up one node, we'll have the registry key under which the driver is stored. Let's use that!
if ((pTempX = FindLast(pdd->DeviceKey,'\\')))
{
lstrcpyn(pDI->Driver, pTemp+1, sizeof(pDI->Driver));
//ATTENTION No point getting version data without a filname:
//We need a new service or something to get the used display driver name
//GetFileVersionData(pDI);
}
*pTemp=cOld;
}
//
// we can find the display driver in a registry key
//
// note: InstalledDisplayDrivers can contain several entries
// to display drivers Since there is no way to find out which
// one is the active one, we always return the first as being
// the display driver!
//
if (ERROR_SUCCESS == RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
pdd->DeviceKey+18,
0,
KEY_QUERY_VALUE ,
&hKey))
{
DWORD dwSize = sizeof(pDI->Driver);
DWORD dwType = 0;
if (ERROR_SUCCESS == RegQueryValueEx(hKey,
TEXT("InstalledDisplayDrivers"),
NULL,
&dwType,
pDI->Driver,
&dwSize))
{
lstrcat(pDI->Driver, TEXT(".dll"));
}
RegCloseKey(hKey);
}
// We have the name, now get the version
pDI->DriverVersion.HighPart = 0;
pDI->DriverVersion.LowPart = 0;
dwSize=GetFileVersionInfoSize(pDI->Driver, 0);
if (dwSize == 0)
return;
buffer = MemAlloc(dwSize);
if (buffer == NULL)
return;
if (!GetFileVersionInfo(pDI->Driver, 0, dwSize, buffer))
{
MemFree(buffer);
return;
}
if (!VerQueryValue(buffer, "\\", (void **)&verinfo, (UINT *)&dwSize))
{
MemFree(buffer);
return;
}
pDI->DriverVersion.HighPart = verinfo->dwFileVersionMS;
pDI->DriverVersion.LowPart = verinfo->dwFileVersionLS;
MemFree(buffer);
}
#endif //win95
void GenerateIdentifier(D3DADAPTER_IDENTIFIER8* pDI)
{
LPDWORD pdw;
CopyMemory(&pDI->DeviceIdentifier, &CLSID_DirectDraw, sizeof(pDI->DeviceIdentifier));
//The device IDs get XORed into the whole GUID with the vendor and device ID in the
//first two DWORDs so they don't get XORed with anything else. This makes it
DDASSERT(sizeof(GUID) >= 4*sizeof(DWORD));
pdw = (LPDWORD) &pDI->DeviceIdentifier;
pdw[0] ^= pDI->VendorId;
pdw[1] ^= pDI->DeviceId;
pdw[2] ^= pDI->SubSysId;
pdw[3] ^= pDI->Revision;
// The driver version gets XORed into the last two DWORDs of the GUID:
pdw[2] ^= pDI->DriverVersion.LowPart;
pdw[3] ^= pDI->DriverVersion.HighPart;
}
void ParseDeviceId(D3DADAPTER_IDENTIFIER8* pDI, char *szDeviceID)
{
char * p;
DPF(5,"Parsing %s",szDeviceID);
pDI->VendorId = 0;
pDI->DeviceId = 0;
pDI->SubSysId = 0;
pDI->Revision = 0;
if (p =_strstr(szDeviceID, "VEN_"))
pDI->VendorId = _atoi(p + 4);
if (p = _strstr(szDeviceID, "DEV_"))
pDI->DeviceId = _atoi(p + 4);
if (p = _strstr(szDeviceID, "SUBSYS_"))
pDI->SubSysId = _atoi(p + 7);
if (p = _strstr(szDeviceID, "REV_"))
pDI->Revision = _atoi(p + 4);
}
void GetAdapterInfo(char* pDriverName, D3DADAPTER_IDENTIFIER8* pDI, BOOL bDisplayDriver, BOOL bGuidOnly, BOOL bDriverName)
{
HRESULT hr = S_OK;
int n;
DISPLAY_DEVICEA dd;
BOOL bFound;
char szDeviceID[MAX_DDDEVICEID_STRING];
#ifndef WINNT
static char szWin9xName[MAX_DDDEVICEID_STRING];
#endif
memset(pDI, 0, sizeof(*pDI));
szDeviceID[0] = 0;
#ifndef WINNT
// On Win9X, it's pretty expensive to get the driver name, so we
// only want to get it when we really need it
szWin9xName[0] = '\0';
if (bDriverName)
{
GetHALName(pDriverName, pDI);
GetFileVersionData(pDI);
}
#endif
// If it's a 3dfx, it's easy
if (!bDisplayDriver)
{
hr = Check3Dfx(pDI);
}
else
{
// Not a 3dfx. Next step: Figure out which display device we
// really are and get description string for it
ZeroMemory(&dd, sizeof(dd));
dd.cb = sizeof(dd);
bFound=FALSE;
for(n=0; xxxEnumDisplayDevicesA(NULL, n, &dd, 0); n++)
{
if (0 == _stricmp(dd.DeviceName, pDriverName))
{
// Found the device. Now we can get some data for it.
lstrcpyn(pDI->Description, dd.DeviceString, sizeof(pDI->Description));
lstrcpyn(szDeviceID, dd.DeviceID, sizeof(szDeviceID));
bFound = TRUE;
#ifdef WINNT
GetNTDriverNameAndVersion(&dd,pDI);
#else
GetWin9XDriverName(&dd, szWin9xName);
if (pDI->Driver[0] == '\0')
{
lstrcpyn(pDI->Driver, szWin9xName, sizeof(pDI->Driver));
}
#endif
break;
}
ZeroMemory(&dd, sizeof(dd));
dd.cb = sizeof(dd);
}
if (!bFound)
{
// Didn't find it: xxxEnumDisplayDevices failed, i.e. we're on 9x or NT4,
if (FAILED(GetDriverInfoFromRegistry("Display", NULL, NULL, pDI, szDeviceID)))
{
return;
}
}
}
if (SUCCEEDED(hr))
{
ParseDeviceId(pDI, szDeviceID);
// Finally, for the primary only, check if a PowerVR is in and functioning
#if 0
if (0 == (dwFlags & DDGDI_GETHOSTIDENTIFIER))
{
if (IsVGADevice(pdrv->cDriverName) && CheckPowerVR(pDI))
{
ParseDeviceId(pDI, szDeviceID);
}
}
#endif
// Munge driver version and ID into the identifier GUID.
GenerateIdentifier(pDI);
// Now get the WHQL level
if (!bGuidOnly)
{
#ifdef WINNT
pDI->WHQLLevel = GetWHQLLevel((LPTSTR)pDI->Driver, NULL);
#else
pDI->WHQLLevel = GetWHQLLevel((LPTSTR)pDI->Driver, szWin9xName);
#endif
}
else
{
pDI->WHQLLevel = 0;
}
}
}
/*
* Voodoo1GoodToGo
*
* The Voodoo 1 driver will succeed the CreateDC call on Voodoo 2, Voodoo 3,
* or Banshee hardware, but if we use the driver beyond that it will hang
* the hardware. This is a work around to not enumerate a Voodoo 1
* driver if the hardware isn't there.
*
* To our knowledge, only two guids were ever used to enumerate Voodoo1
* hardware, so we will look for those guids and assume that anything else
* doesn't need to be checked.
*/
BOOL Voodoo1GoodToGo(GUID * pGuid)
{
D3DADAPTER_IDENTIFIER8 DI;
if (IsEqualIID(pGuid, &guidVoodoo1A) || IsEqualIID(pGuid, &guidVoodoo1B))
{
#ifdef WIN95
char szDeviceID[MAX_DDDEVICEID_STRING];
/*
* Now search the hardware enum key to see if Voodoo 1 hardware exists
*/
if (FAILED(_GetDriverInfoFromRegistry(NULL, "Display", VEN_3DFXVOODOO1, &DI, szDeviceID)))
{
return FALSE;
}
#else
return FALSE;
#endif
}
return TRUE;
}
#ifndef WINNT
/****************************************************************************
*
* FileIsSignedOld
*
* find win95 style of signature
*
****************************************************************************/
BOOL FileIsSignedOld(LPTSTR lpszFile)
{
typedef struct tagIMAGE_DOS_HEADER // DOS .EXE header
{
WORD e_magic; // Magic number
WORD e_cblp; // Bytes on last page of file
WORD e_cp; // Pages in file
WORD e_crlc; // Relocations
WORD e_cparhdr; // Size of header in paragraphs
WORD e_minalloc; // Minimum extra paragraphs needed
WORD e_maxalloc; // Maximum extra paragraphs needed
WORD e_ss; // Initial (relative) SS value
WORD e_sp; // Initial SP value
WORD e_csum; // Checksum
WORD e_ip; // Initial IP value
WORD e_cs; // Initial (relative) CS value
WORD e_lfarlc; // File address of relocation table
WORD e_ovno; // Overlay number
WORD e_res[4]; // Reserved words
WORD e_oemid; // OEM identifier (for e_oeminfo)
WORD e_oeminfo; // OEM information; e_oemid specific
WORD e_res2[10]; // Reserved words
LONG e_lfanew; // File address of new exe header
} IMAGE_DOS_HEADER, * PIMAGE_DOS_HEADER, FAR* LPIMAGE_DOS_HEADER;
typedef struct tagIMAGE_OS2_HEADER // OS/2 .EXE header
{
WORD ne_magic; // Magic number
CHAR ne_ver; // Version number
CHAR ne_rev; // Revision number
WORD ne_enttab; // Offset of Entry Table
WORD ne_cbenttab; // Number of bytes in Entry Table
LONG ne_crc; // Checksum of whole file
WORD ne_flags; // Flag word
WORD ne_autodata; // Automatic data segment number
WORD ne_heap; // Initial heap allocation
WORD ne_stack; // Initial stack allocation
LONG ne_csip; // Initial CS:IP setting
LONG ne_sssp; // Initial SS:SP setting
WORD ne_cseg; // Count of file segments
WORD ne_cmod; // Entries in Module Reference Table
WORD ne_cbnrestab; // Size of non-resident name table
WORD ne_segtab; // Offset of Segment Table
WORD ne_rsrctab; // Offset of Resource Table
WORD ne_restab; // Offset of resident name table
WORD ne_modtab; // Offset of Module Reference Table
WORD ne_imptab; // Offset of Imported Names Table
LONG ne_nrestab; // Offset of Non-resident Names Table
WORD ne_cmovent; // Count of movable entries
WORD ne_align; // Segment alignment shift count
WORD ne_cres; // Count of resource segments
BYTE ne_exetyp; // Target Operating system
BYTE ne_flagsothers; // Other .EXE flags
WORD ne_pretthunks; // offset to return thunks
WORD ne_psegrefbytes; // offset to segment ref. bytes
WORD ne_swaparea; // Minimum code swap area size
WORD ne_expver; // Expected Windows version number
} IMAGE_OS2_HEADER, * PIMAGE_OS2_HEADER, FAR* LPIMAGE_OS2_HEADER;
typedef struct tagWINSTUB
{
IMAGE_DOS_HEADER idh;
BYTE rgb[14];
} WINSTUB, * PWINSTUB, FAR* LPWINSTUB;
typedef struct tagFILEINFO
{
BYTE cbInfo[0x120];
} FILEINFO, * PFILEINFO, FAR* LPFILEINFO;
FILEINFO fi;
int nRC;
LPIMAGE_DOS_HEADER lpmz;
LPIMAGE_OS2_HEADER lpne;
BYTE cbInfo[9+32+2];
BOOL IsSigned = FALSE;
OFSTRUCT OpenStruct;
HFILE hFile;
static WINSTUB winstub = {
{
IMAGE_DOS_SIGNATURE, /* magic */
0, /* bytes on last page - varies */
0, /* pages in file - varies */
0, /* relocations */
4, /* paragraphs in header */
1, /* min allocation */
0xFFFF, /* max allocation */
0, /* initial SS */
0xB8, /* initial SP */
0, /* checksum (ha!) */
0, /* initial IP */
0, /* initial CS */
0x40, /* lfarlc */
0, /* overlay number */
{ 0, 0, 0, 0}, /* reserved */
0, /* oem id */
0, /* oem info */
0, /* compiler bug */
{ 0}, /* reserved */
0x80, /* lfanew */
},
{
0x0E, 0x1F, 0xBA, 0x0E, 0x00, 0xB4, 0x09, 0xCD,
0x21, 0xB8, 0x01, 0x4C, 0xCD, 0x21,
}
};
OpenStruct.cBytes = sizeof(OpenStruct);
lstrcpyn(OpenStruct.szPathName, lpszFile, OFS_MAXPATHNAME);
hFile = OpenFile(lpszFile, &OpenStruct, OF_READ);
if (hFile == HFILE_ERROR)
{
return FALSE;
}
nRC = 0;
ReadFile((HANDLE) hFile, (LPVOID)&fi, sizeof(FILEINFO), &nRC, NULL);
if (nRC != sizeof(FILEINFO))
{
goto FileIsSigned_exit;
}
lpmz = (LPIMAGE_DOS_HEADER)(&fi);
lpne = (LPIMAGE_OS2_HEADER)((WORD)&fi + 0x80);
winstub.idh.e_cblp = lpmz->e_cblp;
winstub.idh.e_cp = lpmz->e_cp;
if (memcmp(&fi, &winstub, sizeof(winstub)) == 0)
{
goto FileIsSigned_exit;
}
memcpy(cbInfo, &((PWINSTUB)(&fi)->cbInfo)->rgb[14], sizeof(cbInfo));
if ((cbInfo[4] != ' ') || // space
(cbInfo[8] != ' ') || // space
(cbInfo[9+32] != '\n') || // return
(cbInfo[9+32+1] != '$')) // Dollar Sign
{
goto FileIsSigned_exit;
}
cbInfo[4] = 0;
cbInfo[8] = 0;
if ((strcmp((const char*)&cbInfo[0], "Cert") != 0) ||
(strcmp((const char*)&cbInfo[5], "DX2") != 0))
{
goto FileIsSigned_exit;
}
IsSigned=TRUE;
FileIsSigned_exit:
_lclose(hFile);
return IsSigned;
}
#endif
/*
* GetWHQLLevel - On Win95, look for old stamp only. On Win2000, use digital
* signature only. On Win98, look for old stamp first, then digital signature
* if no old stamp.
*
* return 0 -- unsigned or uncertified
* return 1 -- driver certified
* return 1997 -- driver certified, PC97 compliant...
* return 1998...
*
*
* arguments:
*
* lpszDriver----Path of driver file
*
*/
DWORD GetWHQLLevel(LPTSTR lpszDriver, LPSTR lpszWin9xDriver)
{
TCHAR szTmp[MAX_PATH];
DWORD dwWhqlLevel = 0;
// here we should rather call
if (GetSystemDirectory(szTmp, MAX_PATH-lstrlen(lpszDriver)-2)==0)
return 0;
lstrcat(szTmp, TEXT("\\"));
lstrcat(szTmp, lpszDriver);
_tcslwr(szTmp);
//
// Look for a digital signature
//
dwWhqlLevel = IsFileDigitallySigned(szTmp);
if (dwWhqlLevel != 0)
{
return dwWhqlLevel;
}
#ifndef WINNT
// It wasn't digitally signed, but it may still have been signed
// the old way. On Win9X, however, lpszDriver actually contains the
// 32 bit HAL name rather than the display driver, but we typically only
// signed the display driver, so we should use lpszWin9xDriver.
if (lpszWin9xDriver[0] != '\0')
{
GetSystemDirectory(szTmp, MAX_PATH-lstrlen(lpszWin9xDriver)-2);
lstrcat(szTmp, TEXT("\\"));
lstrcat(szTmp, lpszWin9xDriver);
}
else
{
GetSystemDirectory(szTmp, MAX_PATH-lstrlen(lpszDriver)-2);
lstrcat(szTmp, TEXT("\\"));
lstrcat(szTmp, lpszDriver);
}
if (FileIsSignedOld(szTmp))
{
return 1;
}
#endif
return 0;
}
DWORD IsFileDigitallySigned(LPTSTR lpszDriver)
{
DWORD dwWHQLLevel=0; // default, driver not certified
CATAPI catapi;
WCHAR *lpFileName;
DRIVER_VER_INFO VerInfo;
TCHAR szBuffer[50];
LPSTR lpAttr;
#ifndef UNICODE
WCHAR wszDriver[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, lpszDriver, -1, wszDriver, MAX_PATH);
lpFileName = wcsrchr(wszDriver, TEXT('\\'));
if (lpFileName==NULL)
{
lpFileName = wszDriver;
}
else
{
lpFileName++;
}
#else
lpFileName = _tcsrchr(lpszDriver, TEXT('\\'));
if (lpFileName==NULL) lpFileName = lpszDriver;
#endif
//
// try to load and initialize the mscat32.dll and wintrust.dll
// these dlls are not available on win95
//
if (InitCATAPI(&catapi))
{
HANDLE hFile;
DWORD cbHashSize=0;
BYTE *pbHash;
BOOL bResult;
//
// create a handle to our driver, because cat api wants handle to file
//
hFile = CreateFile(lpszDriver,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
0,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0
);
if (hFile!=INVALID_HANDLE_VALUE)
{
// first query hash size...
bResult=(*catapi.pCryptCATAdminCalcHashFromFileHandle)(hFile,
&cbHashSize,
NULL,
0);
pbHash=NULL;
if (bResult)
{
// allocate hash
pbHash = MemAlloc(cbHashSize);
}
if (pbHash!=NULL)
{
HCATINFO hPrevCat=NULL;
HANDLE hCatalog=NULL;
WINTRUST_DATA WinTrustData;
WINTRUST_CATALOG_INFO WinTrustCatalogInfo;
GUID guidSubSystemDriver = DRIVER_ACTION_VERIFY;
CRYPTCATATTRIBUTE *lpCat = NULL;
//
// Now get the hash for our file
//
bResult=(*catapi.pCryptCATAdminCalcHashFromFileHandle)(hFile,
&cbHashSize,
pbHash,
0);
if (bResult)
{
hCatalog=(*catapi.pCryptCATAdminEnumCatalogFromHash)(
catapi.hCatAdmin,
pbHash,
cbHashSize,
0,
&hPrevCat);
}
//
// Initialize the structures that
// will be used later on in calls to WinVerifyTrust.
//
ZeroMemory(&WinTrustData, sizeof(WINTRUST_DATA));
WinTrustData.cbStruct = sizeof(WINTRUST_DATA);
WinTrustData.dwUIChoice = WTD_UI_NONE;
WinTrustData.fdwRevocationChecks = WTD_REVOKE_NONE;
WinTrustData.dwUnionChoice = WTD_CHOICE_CATALOG;
WinTrustData.dwStateAction = WTD_STATEACTION_AUTO_CACHE;
WinTrustData.pPolicyCallbackData = (LPVOID)&VerInfo;
ZeroMemory(&VerInfo, sizeof(DRIVER_VER_INFO));
VerInfo.cbStruct = sizeof(DRIVER_VER_INFO);
WinTrustData.pCatalog = &WinTrustCatalogInfo;
ZeroMemory(&WinTrustCatalogInfo, sizeof(WINTRUST_CATALOG_INFO));
WinTrustCatalogInfo.cbStruct = sizeof(WINTRUST_CATALOG_INFO);
WinTrustCatalogInfo.pbCalculatedFileHash = pbHash;
WinTrustCatalogInfo.cbCalculatedFileHash = cbHashSize;
WinTrustCatalogInfo.pcwszMemberTag = lpFileName;
while (hCatalog)
{
CATALOG_INFO CatInfo;
ZeroMemory(&CatInfo, sizeof(CATALOG_INFO));
CatInfo.cbStruct = sizeof(CATALOG_INFO);
if ((*catapi.pCryptCATCatalogInfoFromContext)(hCatalog, &CatInfo, 0))
{
HRESULT hRes;
WinTrustCatalogInfo.pcwszCatalogFilePath = CatInfo.wszCatalogFile;
// Now verify that the file is an actual member of the catalog.
hRes = (*catapi.pWinVerifyTrust)
(NULL, &guidSubSystemDriver, &WinTrustData);
if (hRes == ERROR_SUCCESS)
{
//
// Our driver is certified! Now see if the cat
// info contains the WHQL level
//
CRYPTCATATTRIBUTE *lpCat = NULL;
HANDLE hCat;
dwWHQLLevel=1; // return "certified"
hCat = (*catapi.pCryptCATOpen)(CatInfo.wszCatalogFile, (DWORD)CRYPTCAT_OPEN_EXISTING, (HCRYPTPROV)NULL, 0, 0);
lpCat = (*catapi.pCryptCATGetCatAttrInfo) (hCat, L"KV_DISPLAY");
if (lpCat != NULL)
{
WideCharToMultiByte(CP_ACP, 0, (PUSHORT)lpCat->pbValue, -1, szBuffer, 50, NULL, NULL);
// The value looks like "1:yyyy-mm-dd".
lpAttr = _strstr(szBuffer, ":");
lpAttr++;
lpAttr[4] = '\0';
dwWHQLLevel = atoi(lpAttr) * 0x10000;
lpAttr[7] = '\0';
dwWHQLLevel |= atoi(&lpAttr[5]) * 0x100;
dwWHQLLevel |= atoi(&lpAttr[8]);
}
(*catapi.pCryptCATClose)(hCat);
break;
}
}
//
// iterate through catalogs...
//
hPrevCat=hCatalog;
hCatalog=(*catapi.pCryptCATAdminEnumCatalogFromHash)(
catapi.hCatAdmin,
pbHash,
cbHashSize,
0,
&hPrevCat);
}
//
// we might have to free a catalog context!
//
if (hCatalog)
{
(*catapi.pCryptCATAdminReleaseCatalogContext)
(catapi.hCatAdmin, hCatalog, 0);
}
//
// free hash
//
MemFree(pbHash);
}
CloseHandle(hFile);
}
}
ReleaseCATAPI(&catapi);
return dwWHQLLevel;
}
Reference in a new issue Copy permalink