474 lines
12 KiB
C++
474 lines
12 KiB
C++
// Microsoft Windows
|
|
|
|
// Copyright (C) Microsoft Corporation, 1995 - 1999
|
|
|
|
// File: setreg.cpp
|
|
|
|
// Contents: Set Registry Key Values
|
|
|
|
// See Usage() for syntax and list of options.
|
|
|
|
// Functions: main
|
|
|
|
// History: 28-Jul-96 philh created
|
|
// 02-May-97 xiaohs updated for Localiztion and Consistency
|
|
|
|
#include <windows.h>
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <memory.h>
|
|
#include <time.h>
|
|
#include <wchar.h>
|
|
#include <stdarg.h>
|
|
#include "wintrust.h"
|
|
#include "cryptreg.h"
|
|
#include "resource.h"
|
|
#include "unicode.h"
|
|
|
|
typedef struct _FlagNames
|
|
{
|
|
int idsName;
|
|
DWORD dwMask;
|
|
} FlagNames;
|
|
|
|
static FlagNames SoftPubFlags[] =
|
|
{
|
|
IDS_NAME_TEST_ROOT, WTPF_TRUSTTEST | WTPF_TESTCANBEVALID,
|
|
IDS_NAME_EXPIRATION, WTPF_IGNOREEXPIRATION,
|
|
IDS_NAME_REVOCATION, WTPF_IGNOREREVOKATION,
|
|
IDS_NAME_OFFLINE_INDIVIDUAL, WTPF_OFFLINEOK_IND,
|
|
IDS_NAME_OFFLINE_COMMERCIAL, WTPF_OFFLINEOK_COM,
|
|
IDS_NAME_JAVA_INDIVIDUAL, WTPF_OFFLINEOKNBU_IND,
|
|
IDS_NAME_JAVA_COMMERCIAL, WTPF_OFFLINEOKNBU_COM,
|
|
IDS_NAME_VERSION_ONE, WTPF_VERIFY_V1_OFF,
|
|
IDS_NAME_REVOCATIONONTS, WTPF_IGNOREREVOCATIONONTS,
|
|
IDS_NAME_ALLOWONLYPERTRUST, WTPF_ALLOWONLYPERTRUST
|
|
};
|
|
#define NSOFTPUBFLAGS (sizeof(SoftPubFlags)/sizeof(SoftPubFlags[0]))
|
|
|
|
|
|
//Global Data for loading the string
|
|
#define MAX_STRING_RSC_SIZE 512
|
|
#define OPTION_SWITCH_SIZE 5
|
|
|
|
HMODULE hModule = NULL;
|
|
|
|
WCHAR wszBuffer[MAX_STRING_RSC_SIZE];
|
|
DWORD dwBufferSize = sizeof(wszBuffer) / sizeof(wszBuffer[0]);
|
|
|
|
WCHAR wszBuffer2[MAX_STRING_RSC_SIZE];
|
|
WCHAR wszBuffer3[MAX_STRING_RSC_SIZE];
|
|
|
|
//Global Data for wchar version of the registry path.
|
|
|
|
|
|
// The private version of _wcsicmp
|
|
int IDSwcsicmp(WCHAR* pwsz, int idsString)
|
|
{
|
|
assert(pwsz);
|
|
|
|
//load the string
|
|
if (!LoadStringU(hModule, idsString, wszBuffer, dwBufferSize))
|
|
return -1;
|
|
|
|
return _wcsicmp(pwsz, wszBuffer);
|
|
}
|
|
|
|
|
|
// The private version of wprintf. Input is an ID for a stirng resource and the output is the standard output of wprintf.
|
|
void IDSwprintf(int idsString, ...)
|
|
{
|
|
va_list vaPointer;
|
|
|
|
va_start(vaPointer, idsString);
|
|
LoadStringU(hModule, idsString, wszBuffer, dwBufferSize);//load the string
|
|
vwprintf(wszBuffer, vaPointer);
|
|
}
|
|
|
|
|
|
void IDS_IDS_DWwprintf(int idString, int idStringTwo, DWORD dw)
|
|
{
|
|
LoadStringU(hModule, idString, wszBuffer, dwBufferSize);//load the string
|
|
LoadStringU(hModule, idStringTwo, wszBuffer2, dwBufferSize);//load the string two
|
|
wprintf(wszBuffer, wszBuffer2, dw);
|
|
}
|
|
|
|
|
|
void IDS_IDSwprintf(int idString, int idStringTwo)
|
|
{
|
|
LoadStringU(hModule, idString, wszBuffer, dwBufferSize);//load the string
|
|
LoadStringU(hModule, idStringTwo, wszBuffer2, dwBufferSize);//load the string two
|
|
wprintf(wszBuffer, wszBuffer2);
|
|
}
|
|
|
|
|
|
void IDS_DW_IDS_IDSwprintf(int ids1, DWORD dw, int ids2, int ids3)
|
|
{
|
|
LoadStringU(hModule, ids1, wszBuffer, dwBufferSize);//load the string
|
|
LoadStringU(hModule, ids2, wszBuffer2, dwBufferSize);//load the string two
|
|
LoadStringU(hModule, ids3, wszBuffer3, dwBufferSize);//load the string three
|
|
wprintf(wszBuffer, dw, wszBuffer2, wszBuffer3, dw);
|
|
}
|
|
|
|
|
|
// Convert STR to WSTR
|
|
BOOL SZtoWSZ(LPSTR szStr, LPWSTR* pwsz)
|
|
{
|
|
DWORD dwSize = 0;
|
|
|
|
assert(pwsz);
|
|
|
|
*pwsz = NULL;
|
|
|
|
//return NULL
|
|
if (!szStr)
|
|
return TRUE;
|
|
|
|
dwSize = MultiByteToWideChar(0, 0, szStr, -1, NULL, 0);
|
|
if (dwSize == 0)
|
|
return FALSE;
|
|
|
|
//allocate memory
|
|
*pwsz = (LPWSTR)malloc(dwSize * sizeof(WCHAR));
|
|
if (*pwsz == NULL)
|
|
return FALSE;
|
|
|
|
if (MultiByteToWideChar(0, 0, szStr, -1, *pwsz, dwSize)) {
|
|
return TRUE;
|
|
}
|
|
|
|
free(*pwsz);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Get the hModule hanlder and init two DLLMain.
|
|
BOOL InitModule()
|
|
{
|
|
if (!(hModule = GetModuleHandle(NULL)))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Dispaly the usage
|
|
static void Usage(void)
|
|
{
|
|
IDSwprintf(IDS_SYNTAX);
|
|
IDSwprintf(IDS_OPTIONS);
|
|
IDS_IDSwprintf(IDS_OPTION_Q_DESC, IDS_OPTION_Q);
|
|
IDSwprintf(IDS_ENDLN);
|
|
IDSwprintf(IDS_CHOICES);
|
|
|
|
for (int i = 0; i < NSOFTPUBFLAGS; i++) {
|
|
IDS_IDS_DWwprintf(IDS_DESC, SoftPubFlags[i].idsName, (i + 1));
|
|
}
|
|
|
|
IDSwprintf(IDS_VALUE);
|
|
IDSwprintf(IDS_ENDLN);
|
|
}
|
|
|
|
|
|
// Display Software Publisher State Key Value
|
|
static void DisplaySoftPubKeys()
|
|
{
|
|
DWORD dwState = 0;
|
|
LONG lErr;
|
|
HKEY hKey = NULL;
|
|
DWORD dwType;
|
|
DWORD cbData = sizeof(dwState);
|
|
// WCHAR wszState[10];
|
|
int i = 0;
|
|
LPWSTR wszState = REGNAME_WINTRUST_POLICY_FLAGS;
|
|
|
|
//If load string failed, no need to flag the failure since
|
|
//no output is possible
|
|
// if(!LoadStringU(hModule, IDS_KEY_STATE,wszState, 10))
|
|
// return;
|
|
|
|
lErr = RegOpenHKCUKeyExU(
|
|
HKEY_CURRENT_USER,
|
|
REGPATH_WINTRUST_POLICY_FLAGS,
|
|
0, // dwReserved
|
|
KEY_READ,
|
|
&hKey);
|
|
if (ERROR_SUCCESS != lErr) {
|
|
if (lErr == ERROR_FILE_NOT_FOUND)
|
|
IDSwprintf(IDS_NO_VALUE, REGPATH_WINTRUST_POLICY_FLAGS, NULL);
|
|
else
|
|
IDSwprintf(IDS_REG_OPEN_FAILED,
|
|
REGPATH_WINTRUST_POLICY_FLAGS, L" ", lErr);
|
|
|
|
return;
|
|
}
|
|
|
|
lErr = RegQueryValueExU(
|
|
hKey,
|
|
wszState,
|
|
0, // dwReserved
|
|
&dwType,
|
|
(BYTE*)&dwState,
|
|
&cbData
|
|
);
|
|
if (ERROR_SUCCESS != lErr) {
|
|
if (lErr == ERROR_FILE_NOT_FOUND)
|
|
IDSwprintf(IDS_NO_VALUE, REGPATH_WINTRUST_POLICY_FLAGS, NULL);
|
|
else
|
|
IDSwprintf(IDS_REG_QUERY_FAILED, REGPATH_WINTRUST_POLICY_FLAGS, NULL, lErr);
|
|
|
|
goto CLEANUP;
|
|
|
|
}
|
|
|
|
// 04-Aug-1997 pberkman:
|
|
// added check for reg_binary because on WIN95 OSR2 when the machine is changed
|
|
// from mutli-user profiles to single user profile, the registry DWORD values change to BINARY
|
|
if ((dwType != REG_DWORD) && (dwType != REG_BINARY)) {
|
|
IDSwprintf(IDS_WRONG_TYPE, REGPATH_WINTRUST_POLICY_FLAGS, NULL, dwType);
|
|
goto CLEANUP;
|
|
}
|
|
|
|
IDSwprintf(IDS_STATE, dwState);
|
|
|
|
for (i = 0; i < NSOFTPUBFLAGS; i++) {
|
|
BOOL fOn = (dwState & SoftPubFlags[i].dwMask);
|
|
|
|
int idsValue;
|
|
|
|
switch (SoftPubFlags[i].dwMask) {
|
|
case WTPF_IGNOREREVOCATIONONTS:
|
|
case WTPF_IGNOREREVOKATION:
|
|
case WTPF_IGNOREEXPIRATION:
|
|
// Revocation is a double negative so the bit set
|
|
// means revocation is off.
|
|
idsValue = fOn ? IDS_FALSE : IDS_TRUE;
|
|
break;
|
|
default:
|
|
idsValue = fOn ? IDS_TRUE : IDS_FALSE;
|
|
};
|
|
|
|
if (i < 9) {
|
|
IDS_DW_IDS_IDSwprintf(IDS_DISPLAY_LT_10, (i + 1), SoftPubFlags[i].idsName, idsValue);
|
|
} else {
|
|
IDS_DW_IDS_IDSwprintf(IDS_DISPLAY, (i + 1), SoftPubFlags[i].idsName, idsValue);
|
|
}
|
|
}
|
|
|
|
CLEANUP:
|
|
if (hKey != NULL)
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
|
|
// Set Software Publisher State Key Value
|
|
static void SetSoftPubKey(DWORD dwMask, BOOL fOn)
|
|
{
|
|
DWORD dwState;
|
|
LONG lErr;
|
|
HKEY hKey;
|
|
DWORD dwDisposition;
|
|
DWORD dwType;
|
|
DWORD cbData;
|
|
// WCHAR wszState[10];
|
|
LPWSTR wszState = L"State";
|
|
|
|
//If load string failed, no need to flag the failure since
|
|
//no output is possible
|
|
// if(!LoadStringU(hModule, IDS_KEY_STATE,wszState, 10))
|
|
// return;
|
|
|
|
// Set the State in the registry
|
|
if (ERROR_SUCCESS != (lErr = RegCreateKeyExU(
|
|
HKEY_CURRENT_USER,
|
|
REGPATH_WINTRUST_POLICY_FLAGS,
|
|
0, // dwReserved
|
|
NULL, // lpszClass
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL, // lpSecurityAttributes
|
|
&hKey,
|
|
&dwDisposition))) {
|
|
IDSwprintf(IDS_REG_CREATE_FAILED, REGPATH_WINTRUST_POLICY_FLAGS, L" ", lErr);
|
|
return;
|
|
}
|
|
|
|
dwState = 0;
|
|
cbData = sizeof(dwState);
|
|
lErr = RegQueryValueExU
|
|
(
|
|
hKey,
|
|
wszState,
|
|
0, // dwReserved
|
|
&dwType,
|
|
(BYTE*)&dwState,
|
|
&cbData
|
|
);
|
|
if (ERROR_SUCCESS != lErr) {
|
|
if (lErr == ERROR_FILE_NOT_FOUND) {
|
|
dwState = 0;
|
|
IDSwprintf(IDS_NO_VALUE, REGPATH_WINTRUST_POLICY_FLAGS, NULL);
|
|
} else {
|
|
IDSwprintf(IDS_REG_QUERY_FAILED, REGPATH_WINTRUST_POLICY_FLAGS, NULL, lErr);
|
|
goto CLEANUP;
|
|
}
|
|
} else if ((dwType != REG_DWORD) && (dwType != REG_BINARY)) {
|
|
IDSwprintf(IDS_WRONG_TYPE, REGPATH_WINTRUST_POLICY_FLAGS, NULL, dwType);
|
|
goto CLEANUP;
|
|
}
|
|
|
|
switch (dwMask) {
|
|
case WTPF_IGNOREREVOCATIONONTS:
|
|
case WTPF_IGNOREREVOKATION:
|
|
case WTPF_IGNOREEXPIRATION:
|
|
// Revocation and expiration are a double negative so the bit set
|
|
// means revocation and expriation checking is off.
|
|
fOn = !fOn;
|
|
break;
|
|
default:
|
|
break;
|
|
};
|
|
|
|
if (fOn)
|
|
dwState |= dwMask;
|
|
else
|
|
dwState &= ~dwMask;
|
|
|
|
lErr = RegSetValueExU(
|
|
hKey,
|
|
wszState,
|
|
0, // dwReserved
|
|
REG_DWORD,
|
|
(BYTE*)&dwState,
|
|
sizeof(dwState)
|
|
);
|
|
if (ERROR_SUCCESS != lErr)
|
|
IDSwprintf(IDS_REG_SET_FAILED, lErr);
|
|
|
|
CLEANUP:
|
|
if (hKey)
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
|
|
extern "C" int __cdecl wmain(int argc, WCHAR * *wargv)
|
|
{
|
|
int ReturnStatus = 0;
|
|
LPWSTR* prgwszKeyName = NULL;
|
|
LPWSTR* prgwszValue = NULL;
|
|
DWORD dwIndex = 0;
|
|
DWORD dwCountKey = 0;
|
|
DWORD dwCountValue = 0;
|
|
DWORD dwMask = 0;
|
|
BOOL fOn = TRUE;
|
|
BOOL fQuiet = FALSE;
|
|
DWORD dwEntry = 0;
|
|
WCHAR* pArg = NULL;
|
|
|
|
WCHAR wszSwitch1[OPTION_SWITCH_SIZE];
|
|
WCHAR wszSwitch2[OPTION_SWITCH_SIZE];
|
|
|
|
//get the module handle
|
|
if (!InitModule())
|
|
return -1;
|
|
|
|
//load the strings necessary for parsing the parameters
|
|
if (!LoadStringU(hModule, IDS_SWITCH1, wszSwitch1, OPTION_SWITCH_SIZE) || !LoadStringU(hModule, IDS_SWITCH2, wszSwitch2, OPTION_SWITCH_SIZE))
|
|
return -1;
|
|
|
|
//convert the multitype registry path to the wchar version
|
|
|
|
prgwszKeyName = (LPWSTR*)malloc(sizeof(LPWSTR) * argc);
|
|
prgwszValue = (LPWSTR*)malloc(sizeof(LPWSTR) * argc);
|
|
|
|
if (!prgwszKeyName || !prgwszValue) {
|
|
IDSwprintf(IDS_FAILED);
|
|
ReturnStatus = -1;
|
|
goto CommonReturn;
|
|
}
|
|
|
|
//memset
|
|
memset(prgwszKeyName, 0, sizeof(LPWSTR) * argc);
|
|
memset(prgwszValue, 0, sizeof(LPWSTR) * argc);
|
|
|
|
while (--argc > 0) {
|
|
pArg = *++wargv;
|
|
|
|
if (*pArg == *wszSwitch1 || *pArg == *wszSwitch2) {
|
|
if (IDSwcsicmp(&(pArg[1]), IDS_OPTION_Q) == 0)
|
|
fQuiet = TRUE;
|
|
else
|
|
goto BadUsage;
|
|
} else {
|
|
if (dwCountKey == dwCountValue) {
|
|
prgwszKeyName[dwCountKey] = pArg;
|
|
dwCountKey++;
|
|
} else {
|
|
if (dwCountKey == (dwCountValue + 1)) {
|
|
prgwszValue[dwCountValue] = pArg;
|
|
dwCountValue++;
|
|
} else {
|
|
goto BadUsage;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dwCountKey != dwCountValue) {
|
|
IDSwprintf(IDS_MANY_ARG);
|
|
goto BadUsage;
|
|
}
|
|
|
|
if (dwCountKey == 0) {
|
|
//Display the Software Publisher State Key Values
|
|
DisplaySoftPubKeys();
|
|
goto CommonReturn;
|
|
}
|
|
|
|
for (dwIndex = 0; dwIndex < dwCountKey; dwIndex++) {
|
|
dwEntry = _wtoi(prgwszKeyName[dwIndex]);
|
|
|
|
if (dwEntry < 1 || dwEntry > NSOFTPUBFLAGS + 1) {
|
|
IDSwprintf(IDS_INVALID_CHOICE);
|
|
goto BadUsage;
|
|
}
|
|
|
|
//get the Key mask
|
|
dwMask = SoftPubFlags[dwEntry - 1].dwMask;
|
|
|
|
if (0 == IDSwcsicmp(prgwszValue[dwIndex], IDS_TRUE))
|
|
fOn = TRUE;
|
|
else if (0 == IDSwcsicmp(prgwszValue[dwIndex], IDS_FALSE))
|
|
fOn = FALSE;
|
|
else {
|
|
IDSwprintf(IDS_BAD_VALUE);
|
|
goto BadUsage;
|
|
}
|
|
|
|
SetSoftPubKey(dwMask, fOn);
|
|
}
|
|
|
|
if (!fQuiet) {
|
|
IDSwprintf(IDS_UPDATED);
|
|
DisplaySoftPubKeys();
|
|
}
|
|
|
|
goto CommonReturn;
|
|
|
|
BadUsage:
|
|
Usage();
|
|
ReturnStatus = -1;
|
|
CommonReturn:
|
|
//free the memory
|
|
|
|
if (prgwszKeyName)
|
|
free(prgwszKeyName);
|
|
|
|
if (prgwszValue)
|
|
free(prgwszValue);
|
|
|
|
return ReturnStatus;
|
|
} |