able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/security/services/scerpc/exe/secedit.c

1930 lines
50 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
secedit.c
Abstract:
Command line tool "secedit" to configure/analyze security
Author:
Jin Huang (jinhuang) 7-Nov-1996
--*/
//
// System header files
//
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <string.h>
#include <shlwapi.h>
//
// CRT header files
//
#include <process.h>
#include <wchar.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <limits.h>
#include "secedit.h"
#include "scesetup.h"
#include "stringid.h"
//#include <aclapi.h>
#include <io.h>
#include "userenv.h"
#include <locale.h>
#define GPT_EFS_NEW_PATH TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\GPExtensions\\{B1BE8D72-6EAC-11D2-A4EA-00C04F79F83A}")
#define GPT_SCEDLL_NEW_PATH TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\GPExtensions\\{827D319E-6EAC-11D2-A4EA-00C04F79F83A}")
#define SECEDITP_MAX_STRING_LENGTH 50
#define SCE_ENGINE_GENERATE 1
#define SCE_ENGINE_COMPILE 2
#define SCE_ENGINE_REGISTER 3
#define SCE_ENGINE_REFRESH 4
#define SCE_ENGINE_BROWSE 5
#define SECEDIT_DETAIL_HELP 1
#define SECEDIT_AREA_HELP 2
#define SECEDIT_OVERWRITE_HELP 4
#define SeceditpArgumentConfigure TEXT("/configure")
#define SeceditpArgumentAnalyze TEXT("/analyze")
#define SeceditpArgumentGenerate TEXT("/export")
#define SeceditpArgumentScpPath TEXT("/CFG")
#define SeceditpArgumentSadPath TEXT("/DB")
#define SeceditpArgumentArea TEXT("/areas")
#define SeceditpArgumentLog TEXT("/log")
#define SeceditpArgumentVerbose TEXT("/verbose")
#define SeceditpArgumentQuiet TEXT("/quiet")
#define SeceditpArgumentAppend TEXT("/overwrite")
#define SeceditpArgumentCompile TEXT("/validate")
#define SeceditpArgumentRegister TEXT("/register")
#define SeceditpArgumentRefresh TEXT("/RefreshPolicy")
#define SeceditpArgumentMerge TEXT("/MergedPolicy")
#define SeceditpArgumentEnforce TEXT("/Enforce")
#define SeceditpAreaPolicy TEXT("SECURITYPOLICY")
#define SeceditpAreaUser TEXT("USER_MGMT")
#define SeceditpAreaGroup TEXT("GROUP_MGMT")
#define SeceditpAreaRight TEXT("USER_RIGHTS")
#define SeceditpAreaDsObject TEXT("DSOBJECTS")
#define SeceditpAreaRegistry TEXT("REGKEYS")
#define SeceditpAreaFile TEXT("FILESTORE")
#define SeceditpAreaService TEXT("SERVICES")
#define SCE_LOCAL_FREE(ptr) if (ptr != NULL) LocalFree(ptr)
HMODULE hMod=NULL;
static DWORD dOptions=0;
static HANDLE hCmdToolLogFile=INVALID_HANDLE_VALUE;
static PWSTR LogFile=NULL;
VOID
ScepPrintHelp(DWORD nLevel);
WCHAR *
SecEditPConvertToFullPath(
WCHAR *UserFilename,
DWORD *retCode
);
BOOL
ScepCmdToolLogInit(
PWSTR logname
);
VOID
ScepCmdToolLogWrite(
PWSTR pErrString
);
SCESTATUS
ScepCmdToolLogClose(
);
SCESTATUS
SeceditpErrOut(
IN DWORD rc,
IN LPTSTR buf OPTIONAL
);
DWORD
SeceditpSceStatusToDosError(
IN SCESTATUS SceStatus
);
BOOL CALLBACK
SceCmdVerboseCallback(
IN HANDLE CallbackHandle,
IN AREA_INFORMATION Area,
IN DWORD TotalTicks,
IN DWORD CurrentTicks
);
DWORD
pProgressRoutine(
IN PWSTR StringUpdate
);
BOOL
ScepPrintConfigureWarning();
BOOL CALLBACK
pBrowseCallback(
IN LONG ID,
IN PWSTR KeyName OPTIONAL,
IN PWSTR GpoName OPTIONAL,
IN PWSTR Value OPTIONAL,
IN DWORD Len
);
#define SECEDIT_OPTION_DEBUG 0x01L
#define SECEDIT_OPTION_VERBOSE 0x02L
#define SECEDIT_OPTION_QUIET 0x04L
#define SECEDIT_OPTION_OVERWRITE 0x08L
#define SECEDIT_OPTION_MACHINE 0x10L
#define SECEDIT_OPTION_MERGE 0x20L
#define SECEDIT_OPTION_APPEND 0x40L
#define SECEDIT_OPTION_ENFORCE 0x80L
int __cdecl
My_wprintf(
const wchar_t *format,
...
);
int __cdecl
My_fwprintf(
FILE *str,
const wchar_t *format,
...
);
int __cdecl
My_vfwprintf(
FILE *str,
const wchar_t *format,
va_list argptr
);
int __cdecl
My_printf(
const char *format,
...
);
int __cdecl wmain(int argc, WCHAR * argv[])
{
PWSTR InfFile=NULL;
// PWSTR LogFile=NULL;
PWSTR SadFile=NULL;
PWSTR pTemp=NULL;
AREA_INFORMATION Area=AREA_ALL;
SCESTATUS rc;
int rCode=0;
DWORD EngineType=0;
LONG i;
DWORD j;
DWORD Len, TotalLen;
BOOL bTest=FALSE;
BOOL bVerbose=TRUE;
BOOL bQuiet=FALSE;
BOOL bAppend=TRUE;
PVOID hProfile=NULL;
PSCE_PROFILE_INFO ProfileInfo=NULL;
PSCE_ERROR_LOG_INFO ErrBuf=NULL;
PSCE_ERROR_LOG_INFO pErr;
DWORD dWarning=0;
WCHAR LineString[256];
WCHAR WarningStr[256];
BOOL bMachine=FALSE, bMerge=FALSE, bEnforce=FALSE;
UINT rId=0;
HKEY hKey=NULL, hKey1=NULL;
UINT ConsoleCP;
char szConsoleCP[6];
// check for /quiet and LogFile if any - set relevant flags (need this info immediately to log errors)
for ( i=1; i<argc; i++ ){
if ( _wcsicmp(argv[i], SeceditpArgumentLog ) == 0 ) {
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
LogFile = SecEditPConvertToFullPath(argv[i+1], &rCode);
if (rCode == 2) {
goto Done;
}
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
}
if ( _wcsicmp(argv[i], SeceditpArgumentQuiet ) == 0 ) {
bQuiet = TRUE;
dOptions |= SCE_DISABLE_LOG;
}
}
if ( rCode == 0 )
ScepCmdToolLogInit(LogFile);
ConsoleCP = GetConsoleOutputCP();
// szConsoleCP[0] = '.';
// itoa(ConsoleCP, &szConsoleCP[1], 10);
sprintf(szConsoleCP, ".%d", ConsoleCP);
// setlocale(LC_ALL, ".OCP");
setlocale(LC_ALL, szConsoleCP);
hMod = GetModuleHandle(NULL);
if ( hMod == NULL ) {
My_wprintf(L"Cannot find the module handle\n");
return 2; // system error
}
for ( i=1; i<argc; i++ )
if ( _wcsicmp(argv[i], L"/?") == 0 ) {
ScepPrintHelp(0);
goto Done;
}
if ( argc < 2 ) {
ScepPrintHelp(0);
return 1;
} else {
for ( i=1; i<argc; i++ ) {
SCE_LOCAL_FREE(pTemp);
Len = wcslen(argv[i]);
pTemp = (PWSTR)LocalAlloc( 0, (Len+1)*sizeof(WCHAR));
if ( pTemp == NULL ) {
My_wprintf(L"Not enough memory\n");
rCode=2; //system error
goto Done;
}
wcscpy(pTemp, argv[i]);
//
// configure engine type ?
//
if ( _wcsicmp(pTemp, SeceditpArgumentConfigure) == 0 ) {
if ( EngineType != 0 ) {
ScepPrintHelp(EngineType);
rCode = 1; // invalid parameter
goto Done;
}
EngineType = SCE_ENGINE_SCP;
continue;
}
//
// analyze engine type ?
//
if ( _wcsicmp(pTemp, SeceditpArgumentAnalyze) == 0 ) {
if ( EngineType != 0 ) {
ScepPrintHelp(EngineType);
rCode = 1; //invalid parameter
goto Done;
}
EngineType = SCE_ENGINE_SAP;
continue;
}
//
// generate template ?
//
if ( _wcsicmp(pTemp, SeceditpArgumentGenerate) == 0 ) {
if ( EngineType != 0 ) {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
EngineType = SCE_ENGINE_GENERATE;
continue;
}
//
// compile a template ?
//
if ( _wcsicmp(pTemp, SeceditpArgumentCompile) == 0 ) {
if ( EngineType != 0 ) {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
EngineType = SCE_ENGINE_COMPILE;
//
// compile requires a INF template name
//
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
InfFile = SecEditPConvertToFullPath(argv[i+1], &rCode);
if (rCode == 2) {
goto Done;
}
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
}
//
// register a template for registry values ?
//
if ( _wcsicmp(pTemp, SeceditpArgumentRegister) == 0 ) {
if ( EngineType != 0 ) {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
EngineType = SCE_ENGINE_REGISTER;
//
// register requires a INF template name
//
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
InfFile = SecEditPConvertToFullPath(argv[i+1], &rCode);
if (rCode == 2) {
goto Done;
}
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
}
//
// refresh policy
//
if ( _wcsicmp(pTemp, SeceditpArgumentRefresh) == 0 ) {
//
// do not support refresh policy because it's supported by refgp.exe
//
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
/*
if ( EngineType != 0 ) {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
EngineType = SCE_ENGINE_REFRESH;
//
// next argument is the policy area
//
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
if ( 0 == _wcsicmp(argv[i+1], L"MACHINE_POLICY") ) {
bMachine = TRUE;
} else if ( 0 == _wcsicmp(argv[i+1], L"USER_POLICY") ) {
bMachine = FALSE;
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
*/
}
if ( _wcsicmp(pTemp, L"/browse") == 0 ) {
if ( EngineType != 0 ) {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
EngineType = SCE_ENGINE_BROWSE;
//
// next argument is the table
//
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
if ( 0 == _wcsicmp(argv[i+1], L"scp") ) {
dWarning = SCE_ENGINE_SCP;
} else if ( 0 == _wcsicmp(argv[i+1], L"smp") ) {
dWarning = SCE_ENGINE_SMP;
} else if ( 0 == _wcsicmp(argv[i+1], L"sap") ) {
dWarning = SCE_ENGINE_SAP;
} else if ( 0 == _wcsicmp(argv[i+1], L"tattoo") ) {
dWarning = SCE_ENGINE_SAP;
bMerge = TRUE;
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
}
if ( _wcsicmp(pTemp, L"/debug") == 0 ) {
bTest = TRUE;
continue;
}
if ( _wcsicmp(pTemp, SeceditpArgumentVerbose ) == 0 ) {
bVerbose = TRUE;
continue;
}
if ( _wcsicmp(pTemp, SeceditpArgumentQuiet ) == 0 ) {
bQuiet = TRUE;
continue;
}
if ( _wcsicmp(pTemp, SeceditpArgumentAppend ) == 0 ) {
bAppend = FALSE;
continue;
}
if ( _wcsicmp(pTemp, SeceditpArgumentMerge ) == 0 ) {
bMerge = TRUE;
continue;
}
if ( _wcsicmp(pTemp, SeceditpArgumentEnforce ) == 0 ) {
bEnforce = TRUE;
continue;
}
//
// scp profile name, it may be empty "/scppath"
//
if ( _wcsicmp(pTemp, SeceditpArgumentScpPath) == 0 ) {
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
InfFile = SecEditPConvertToFullPath(argv[i+1], &rCode);
if (rCode == 2) {
goto Done;
}
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
}
//
// sad database name, it may be empty
//
if ( _wcsicmp(pTemp, SeceditpArgumentSadPath) == 0 ) {
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
SadFile = SecEditPConvertToFullPath(argv[i+1], &rCode);
if (rCode == 2) {
goto Done;
}
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
}
//
// area(s)
//
if ( _wcsicmp(pTemp, SeceditpArgumentArea ) == 0 ) {
//
//
for ( j=(DWORD)i, Area=0; j+1 < (DWORD)argc && argv[j+1][0] != L'/'; j++ ) {
SCE_LOCAL_FREE(pTemp);
Len = wcslen(argv[j+1]);
pTemp = (PWSTR)LocalAlloc( 0, (Len+1)*sizeof(WCHAR));
if ( pTemp == NULL ) {
My_wprintf(L"Not enough memory\n");
rCode = 2;
goto Done;
}
wcscpy(pTemp, argv[j+1]);
//
// Process all arguments for Areas
//
if ( _wcsicmp( pTemp, SeceditpAreaPolicy) == 0 ) {
// security policy
Area |= AREA_SECURITY_POLICY;
continue;
}
/*
if ( _wcsicmp( pTemp, SeceditpAreaUser) == 0 ) {
// user
Area |= AREA_USER_SETTINGS;
continue;
}
*/
if ( _wcsicmp( pTemp, SeceditpAreaGroup) == 0 ) {
// group
Area |= AREA_GROUP_MEMBERSHIP;
continue;
}
if ( _wcsicmp( pTemp, SeceditpAreaRight) == 0 ) {
// privilege rights
Area |= AREA_PRIVILEGES;
continue;
}
#if 0
if ( _wcsicmp( pTemp, SeceditpAreaDsObject) == 0 ) {
// ds objects
Area |= AREA_DS_OBJECTS;
continue;
}
#endif
if ( _wcsicmp( pTemp, SeceditpAreaRegistry) == 0 ) {
// Registry
Area |= AREA_REGISTRY_SECURITY;
continue;
}
if ( _wcsicmp( pTemp, SeceditpAreaFile) == 0 ) {
// file
Area |= AREA_FILE_SECURITY;
continue;
}
if ( _wcsicmp( pTemp, SeceditpAreaService) == 0 ) {
// services
Area |= AREA_SYSTEM_SERVICE;
continue;
}
//
// unrecognized parameter
//
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i = (LONG)j;
continue;
}
//
// ignore if "/log filename" since already processed at the beginning
//
if ( _wcsicmp(pTemp, SeceditpArgumentLog ) == 0 ) {
if ( i+1 < argc && argv[i+1][0] != L'/' ) {
} else {
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
i++;
continue;
}
//
// unrecognized argument
//
ScepPrintHelp(EngineType);
rCode = 1;
goto Done;
}
}
if ( EngineType == 0 ) {
ScepPrintHelp(0);
rCode = 1;
goto Done;
}
SetConsoleCtrlHandler(NULL, TRUE);
//
// Initialize
//
if ( bTest ) {
dOptions |= SCE_DEBUG_LOG;
} else if ( bVerbose ) {
dOptions |= SCE_VERBOSE_LOG;
}
switch ( EngineType ) {
case SCE_ENGINE_SCP:
//
// configure the system
//
if ( (SadFile == NULL) ||
SceIsSystemDatabase(SadFile) ) {
rc = SCESTATUS_INVALID_PARAMETER;
LoadString( hMod,
SECEDITP_CONFIG_NOT_ALLOWED_1,
LineString,
256
);
My_wprintf(LineString);
LoadString( hMod,
SECEDITP_CONFIG_NOT_ALLOWED_2,
LineString,
256
);
My_wprintf(LineString);
EngineType = 0;
} else {
bMachine = TRUE;
if ( bAppend && InfFile != NULL ) {
dOptions |= SCE_UPDATE_DB;
} else {
dOptions |= SCE_OVERWRITE_DB;
if ( FALSE == bAppend && InfFile != NULL && !bQuiet ) {
//
// will overwrite the database with the new inf file.
// warn users for this serious problem.
// If this is a normal user logon, the operation will fail
// by the server site.
//
bMachine = ScepPrintConfigureWarning(); // temp. use of bMachine
}
}
if ( bMachine ) {
rc = SceConfigureSystem(
NULL,
InfFile,
SadFile,
LogFile,
dOptions,
Area,
(bVerbose || bTest ) ?
(PSCE_AREA_CALLBACK_ROUTINE)SceCmdVerboseCallback : NULL,
NULL,
&dWarning
);
} else {
rc = SCESTATUS_SUCCESS;
dWarning = ERROR_REQUEST_ABORTED;
goto Done;
}
}
break;
case SCE_ENGINE_SAP:
//
// analyze the system
//
if ( !bTest )
Area = AREA_ALL;
// if ( bAppend && InfFile != NULL ) {
// dOptions |= SCE_UPDATE_DB;
// } else {
// dOptions |= SCE_OVERWRITE_DB;
// }
dOptions |= SCE_OVERWRITE_DB;
// if ( InfFile == NULL || SadFile != NULL ) {
if ( (SadFile != NULL) &&
!SceIsSystemDatabase(SadFile) ) {
rc = SceAnalyzeSystem(
NULL,
InfFile,
SadFile,
LogFile,
dOptions,
Area,
(bVerbose || bTest ) ?
(PSCE_AREA_CALLBACK_ROUTINE)SceCmdVerboseCallback : NULL,
NULL,
&dWarning
);
} else {
rc = SCESTATUS_INVALID_PARAMETER;
LoadString( hMod,
SECEDITP_ANALYSIS_NOT_ALLOWED_1,
LineString,
256
);
My_wprintf(LineString);
LoadString( hMod,
SECEDITP_ANALYSIS_NOT_ALLOWED_2,
LineString,
256
);
My_wprintf(LineString);
EngineType = 0;
}
break;
case SCE_ENGINE_GENERATE:
if ( InfFile != NULL ) {
//
// must have a inf file name
//
rc = SceSetupGenerateTemplate(NULL,
SadFile,
bMerge,
InfFile,
LogFile,
Area);
if (ERROR_NOT_ENOUGH_MEMORY == rc ||
ERROR_SERVICE_ALREADY_RUNNING == rc ) {
rCode = 2;
} else if ( rc ) {
rCode = 1;
}
} else {
rCode = 1;
ScepPrintHelp(EngineType);
goto Done;
}
break;
case SCE_ENGINE_BROWSE:
//
// must have a inf file name
//
if ( Area == 0 ) {
Area = AREA_ALL;
}
rc = SceBrowseDatabaseTable(SadFile,
(SCETYPE)dWarning,
Area,
bMerge,
(PSCE_BROWSE_CALLBACK_ROUTINE)pBrowseCallback
);
dWarning = 0; // reset the value
if (ERROR_NOT_ENOUGH_MEMORY == rc ||
ERROR_SERVICE_ALREADY_RUNNING == rc ) {
rCode = 2;
} else if ( rc ) {
rCode = 1;
}
break;
case SCE_ENGINE_COMPILE:
rc = 0;
if ( InfFile != NULL ) {
//
// must have a inf file name
//
rc = SceOpenProfile(InfFile,
SCE_INF_FORMAT,
&hProfile);
if ( rc == SCESTATUS_SUCCESS && hProfile ) {
//
// get profile info will parse the template first
//
rc = SceGetSecurityProfileInfo(hProfile,
SCE_ENGINE_SCP,
AREA_ALL,
&ProfileInfo,
&ErrBuf);
if ( SCESTATUS_SUCCESS == rc && ErrBuf ) {
//
// this is a new version template
//
LoadString( hMod,
SECEDITP_TEMPLATE_NEWVERSION,
LineString,
256
);
SeceditpErrOut(0, LineString);
rc = SCESTATUS_INVALID_DATA;
}
for ( pErr=ErrBuf; pErr != NULL; pErr = pErr->next ) {
if ( pErr->buffer != NULL ) {
SeceditpErrOut( pErr->rc, pErr->buffer );
}
}
SceFreeMemory((PVOID)ErrBuf, SCE_STRUCT_ERROR_LOG_INFO);
ErrBuf = NULL;
if ( ProfileInfo != NULL ) {
SceFreeMemory((PVOID)ProfileInfo, Area);
LocalFree(ProfileInfo);
}
SceCloseProfile(&hProfile);
} else {
if (SCESTATUS_OTHER_ERROR == rc) {
LoadString( hMod,
SECEDITP_FILE_MAY_CORRUPTED,
LineString,
256
);
}
else {
LoadString( hMod,
SECEDITP_CANNOT_FIND_TEMPLATE,
LineString,
256
);
}
SeceditpErrOut(SeceditpSceStatusToDosError(rc),
LineString);
}
if (SCESTATUS_NOT_ENOUGH_RESOURCE == rc ||
SCESTATUS_ALREADY_RUNNING == rc ) {
rCode = 2;
} else if ( rc ) {
rCode = 1;
}
} else {
rCode = 1;
ScepPrintHelp(EngineType);
goto Done;
}
if ( SCESTATUS_SUCCESS == rc && InfFile) {
LoadString( hMod,
SECEDITP_COMPILE_OK,
LineString,
256
);
My_wprintf(LineString, InfFile);
}
break;
case SCE_ENGINE_REGISTER:
rc = 0;
if ( InfFile != NULL ) {
rc = SceRegisterRegValues(InfFile);
if (ERROR_NOT_ENOUGH_MEMORY == rc ) {
rCode = 2;
} else if ( rc ) {
rCode = 1;
}
} else {
rCode = 1;
ScepPrintHelp(EngineType);
goto Done;
}
if ( SCESTATUS_SUCCESS == rc && InfFile) {
LoadString( hMod,
SECEDITP_REGISTER_OK,
LineString,
256
);
My_wprintf(LineString, InfFile);
}
break;
case SCE_ENGINE_REFRESH:
break;
default:
rc = 0;
rCode = 1;
ScepPrintHelp(EngineType);
break;
}
SetConsoleCtrlHandler(NULL, FALSE);
if ( EngineType == SCE_ENGINE_SCP ||
EngineType == SCE_ENGINE_SAP ||
EngineType == SCE_ENGINE_GENERATE ||
EngineType == SCE_ENGINE_BROWSE ) {
My_wprintf(L" \n");
if ( SCESTATUS_SUCCESS == rc ) {
if ( ERROR_SUCCESS == dWarning ) {
rId = SECEDITP_TASK_COMPLETE_NO_ERROR;
} else {
// SeceditpErrOut( dWarning, NULL);
rId = SECEDITP_TASK_COMPLETE_WARNING;
}
} else {
SeceditpErrOut( SeceditpSceStatusToDosError(rc), NULL);
rId = SECEDITP_TASK_COMPLETE_ERROR;
}
LoadString( hMod,
rId,
LineString,
256
);
if ( rId == SECEDITP_TASK_COMPLETE_WARNING ) {
//
// explain the warnings
//
WarningStr[0] = L'\0';
switch ( dWarning ) {
case ERROR_FILE_NOT_FOUND:
case ERROR_PATH_NOT_FOUND:
LoadString( hMod,
SECEDITP_WARNING_NOT_FOUND,
WarningStr,
256
);
break;
case ERROR_SHARING_VIOLATION:
LoadString( hMod,
SECEDITP_WARNING_IN_USE,
WarningStr,
256
);
break;
default:
LoadString( hMod,
SECEDITP_WARNING_OTHER_WARNING,
WarningStr,
256
);
break;
}
My_wprintf(LineString, WarningStr);
} else {
My_wprintf(LineString);
}
if (bQuiet == FALSE) {
if ( LogFile ) {
LoadString( hMod,
SECEDITP_TASK_SEE_LOG,
LineString,
256
);
My_wprintf(LineString, LogFile);
} else {
LoadString( hMod,
SECEDITP_TASK_SEE_DEF_LOG,
LineString,
256
);
My_wprintf(L"%s", LineString);
}
}
}
Done:
if ( dOptions & SCE_DISABLE_LOG ){
ScepCmdToolLogClose();
}
SCE_LOCAL_FREE(InfFile);
SCE_LOCAL_FREE(SadFile);
SCE_LOCAL_FREE(LogFile);
SCE_LOCAL_FREE(pTemp);
FreeLibrary( hMod );
if ( rCode )
return rCode;
else if ( rc ) {
if (SCESTATUS_NOT_ENOUGH_RESOURCE == rc ||
SCESTATUS_ALREADY_RUNNING == rc )
return 2;
else
return 1;
} else if ( dWarning ) {
return 3;
} else
return 0;
}
VOID
ScepPrintHelp(DWORD nLevel)
{
PROCESS_INFORMATION ProcInfo;
STARTUPINFOA StartInfo;
BOOL fOk;
RtlZeroMemory(&StartInfo,sizeof(StartInfo));
StartInfo.cb = sizeof(StartInfo);
StartInfo.dwFlags = STARTF_USESHOWWINDOW;
StartInfo.wShowWindow = (WORD)SW_SHOWNORMAL;
fOk = CreateProcessA(NULL, "hh secedit.chm",
NULL, NULL, FALSE,
0,
NULL,
NULL,
&StartInfo,
&ProcInfo
);
if ( fOk ) {
CloseHandle(ProcInfo.hProcess);
CloseHandle(ProcInfo.hThread);
}
}
SCESTATUS
SeceditpErrOut(
IN DWORD rc,
IN LPTSTR buf OPTIONAL
)
{
LPVOID lpMsgBuf=NULL;
if ( rc != NO_ERROR ) {
//
// get error description of rc
//
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
rc,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR)&lpMsgBuf,
0,
NULL
);
}
//
// Display to screen
//
if ( buf ) {
if (lpMsgBuf != NULL )
My_fwprintf( stdout, L"%s %s\n", (PWSTR)lpMsgBuf, buf );
else
My_fwprintf( stdout, L"%s\n", buf );
} else {
if (lpMsgBuf != NULL )
My_fwprintf( stdout, L"%s\n", (PWSTR)lpMsgBuf);
}
SCE_LOCAL_FREE(lpMsgBuf);
return(SCESTATUS_SUCCESS);
}
DWORD
SeceditpSceStatusToDosError(
IN SCESTATUS SceStatus
)
// converts SCESTATUS error code to dos error defined in winerror.h
{
switch(SceStatus) {
case SCESTATUS_SUCCESS:
return(NO_ERROR);
case SCESTATUS_OTHER_ERROR:
return(ERROR_EXTENDED_ERROR);
case SCESTATUS_INVALID_PARAMETER:
return(ERROR_INVALID_PARAMETER);
case SCESTATUS_RECORD_NOT_FOUND:
return(ERROR_NO_MORE_ITEMS);
case SCESTATUS_NO_MAPPING:
return(ERROR_NONE_MAPPED);
case SCESTATUS_TRUST_FAIL:
return(ERROR_TRUSTED_DOMAIN_FAILURE);
case SCESTATUS_INVALID_DATA:
return(ERROR_INVALID_DATA);
case SCESTATUS_OBJECT_EXIST:
return(ERROR_FILE_EXISTS);
case SCESTATUS_BUFFER_TOO_SMALL:
return(ERROR_INSUFFICIENT_BUFFER);
case SCESTATUS_PROFILE_NOT_FOUND:
return(ERROR_FILE_NOT_FOUND);
case SCESTATUS_BAD_FORMAT:
return(ERROR_BAD_FORMAT);
case SCESTATUS_NOT_ENOUGH_RESOURCE:
return(ERROR_NOT_ENOUGH_MEMORY);
case SCESTATUS_ACCESS_DENIED:
return(ERROR_ACCESS_DENIED);
case SCESTATUS_CANT_DELETE:
return(ERROR_CURRENT_DIRECTORY);
case SCESTATUS_PREFIX_OVERFLOW:
return(ERROR_BUFFER_OVERFLOW);
case SCESTATUS_ALREADY_RUNNING:
return(ERROR_SERVICE_ALREADY_RUNNING);
case SCESTATUS_SERVICE_NOT_SUPPORT:
return(ERROR_NOT_SUPPORTED);
case SCESTATUS_MOD_NOT_FOUND:
return(ERROR_MOD_NOT_FOUND);
case SCESTATUS_EXCEPTION_IN_SERVER:
return(ERROR_EXCEPTION_IN_SERVICE);
case SCESTATUS_JET_DATABASE_ERROR:
return(ERROR_DATABASE_FAILURE);
case SCESTATUS_TIMEOUT:
return(ERROR_TIMEOUT);
case SCESTATUS_PENDING_IGNORE:
return(ERROR_IO_PENDING);
case SCESTATUS_SPECIAL_ACCOUNT:
return(ERROR_SPECIAL_ACCOUNT);
default:
return(ERROR_EXTENDED_ERROR);
}
}
BOOL CALLBACK
SceCmdVerboseCallback(
IN HANDLE CallbackHandle,
IN AREA_INFORMATION Area,
IN DWORD TotalTicks,
IN DWORD CurrentTicks
)
{
LPCTSTR SectionName;
DWORD nProg;
WCHAR LineString[256];
switch ( Area ) {
case AREA_SECURITY_POLICY:
SectionName = NULL;
break;
case AREA_PRIVILEGES:
SectionName = szPrivilegeRights;
break;
case AREA_GROUP_MEMBERSHIP:
SectionName = szGroupMembership;
break;
case AREA_FILE_SECURITY:
SectionName = szFileSecurity;
break;
case AREA_REGISTRY_SECURITY:
SectionName = szRegistryKeys;
break;
case AREA_DS_OBJECTS:
SectionName = szDSSecurity;
break;
case AREA_SYSTEM_SERVICE:
SectionName = NULL;
break;
default:
SectionName = NULL;
break;
}
if ( TotalTicks ) {
nProg = (CurrentTicks+1)*100/TotalTicks;
if ( nProg > 100 ) {
nProg = 100;
}
} else {
nProg = 0;
}
if ( SectionName ) {
LoadString( hMod,
SECEDITP_WITH_SECTIONNAME,
LineString,
256
);
My_wprintf(LineString, nProg, CurrentTicks, TotalTicks, SectionName);
} else if ( Area == AREA_SECURITY_POLICY ) {
LoadString( hMod,
SECEDITP_SICURITY_POLICY,
LineString,
256
);
My_wprintf(LineString, nProg, CurrentTicks, TotalTicks);
} else if ( Area == AREA_SYSTEM_SERVICE ) {
LoadString( hMod,
SECEDITP_SYSTEM_SERVICE,
LineString,
256
);
My_wprintf(LineString, nProg, CurrentTicks, TotalTicks);
} else {
LoadString( hMod,
SECEDITP_NO_SECTIONNAME,
LineString,
256
);
My_wprintf(LineString, nProg, CurrentTicks, TotalTicks);
}
return TRUE;
}
DWORD
pProgressRoutine(
IN PWSTR StringUpdate
)
{
if ( StringUpdate ) {
My_wprintf(L"Process %s\n", StringUpdate);
}
return 0;
}
BOOL
ScepPrintConfigureWarning()
{
WCHAR LineString[256];
WCHAR wch;
LoadString( hMod,
SECEDITP_CONFIG_WARNING_LINE1,
LineString,
256
);
My_wprintf(LineString);
LoadString( hMod,
SECEDITP_CONFIG_WARNING_LINE2,
LineString,
256
);
My_wprintf(LineString);
LoadString( hMod,
SECEDITP_CONFIG_WARNING_LINE3,
LineString,
256
);
My_wprintf(LineString);
//
// get user input
//
LoadString( hMod,
SECEDITP_CONFIG_WARNING_CONFIRM,
LineString,
256
);
My_wprintf(LineString);
wch = getwc(stdin);
getwc(stdin);
//
// load string for Yes
//
LineString[0] = L'\0';
LoadString( hMod,
SECEDITP_IDS_YES,
LineString,
256
);
if ( towlower(wch) == towlower(LineString[0]) ) {
return(TRUE);
} else {
return(FALSE);
}
}
BOOL CALLBACK
pBrowseCallback(
IN LONG ID,
IN PWSTR KeyName OPTIONAL,
IN PWSTR GpoName OPTIONAL,
IN PWSTR Value OPTIONAL,
IN DWORD Len
)
{
BYTE *pb=NULL;
My_wprintf(L"\n");
if ( ID > 0 ) {
My_printf("%d\t", ID);
}
if (GpoName ) {
My_wprintf(L"%s ", GpoName);
}
if ( KeyName ) {
My_wprintf(L"%s", KeyName);
if ( Value && Len > 0 ) {
if ( Len > 30 ) {
My_wprintf(L"\n");
} else {
My_wprintf(L"\t");
}
if ( iswprint(Value[0]) ) {
My_wprintf(L"%c%s\n", Value[0], (Len>1) ? Value+1 : L"");
} else {
pb = (BYTE *)Value;
My_wprintf(L"%d %d ", pb[1], pb[0]);
/*
if ( isprint( pc[0] ) ) {
My_printf("%c ", pc[0] );
} else {
My_printf("%d ", (int)(pc[0]) );
}
if ( isprint( pc[1] ) ) {
My_printf("%c ", pc[1] );
} else {
My_printf("%d ", (int)pc[1] );
}
*/
if ( Len > 1 && Value[1] != L'\0' ) {
My_wprintf(L"%s\n", Value+1);
} else {
My_wprintf(L"No value\n");
}
}
} else {
My_wprintf(L"\n");
}
} else {
My_wprintf(L"\n");
}
return(TRUE);
}
/***
* My_wprintf(format) - print formatted data
*
* Prints Unicode formatted string to console window using WriteConsoleW.
* Note: This My_wprintf() is used to workaround the problem in c-runtime
* which looks up LC_CTYPE even for Unicode string.
*
*/
int __cdecl
My_wprintf(
const wchar_t *format,
...
)
{
DWORD cchWChar = 0;
DWORD dwBytesWritten;
va_list args;
va_start( args, format );
cchWChar = My_vfwprintf(stdout, format, args);
va_end(args);
return cchWChar;
}
/***
* My_fwprintf(stream, format) - print formatted data
*
* Prints Unicode formatted string to console window using WriteConsoleW.
* Note: This My_fwprintf() is used to workaround the problem in c-runtime
* which looks up LC_CTYPE even for Unicode string.
*
*/
int __cdecl
My_fwprintf(
FILE *str,
const wchar_t *format,
...
)
{
DWORD cchWChar = 0;
va_list args;
va_start( args, format );
cchWChar = My_vfwprintf(str, format, args);
va_end(args);
return cchWChar;
}
int __cdecl
My_vfwprintf(
FILE *str,
const wchar_t *format,
va_list argptr
)
{
HANDLE hOut;
// if the /quiet option is specified, suppress printing to stdout
// and instead print to the logfile. If logfile not specified
// don't print at all
if (dOptions & SCE_DISABLE_LOG){
DWORD cchWChar = 0;
LPTSTR szBufferMessage = (LPTSTR) LocalAlloc (LPTR, 2048 * sizeof(TCHAR));
if (szBufferMessage) {
vswprintf( szBufferMessage, format, argptr );
cchWChar = wcslen(szBufferMessage);
// remove trailing LFs
if (szBufferMessage[cchWChar-1] == L'\n')
szBufferMessage[cchWChar-1] = L'\0';
// remove leading LFs
if (szBufferMessage[0] == L'\n')
szBufferMessage[0] = L' ';
ScepCmdToolLogWrite(szBufferMessage);
SCE_LOCAL_FREE(szBufferMessage);
}
return cchWChar;
}
if (str == stderr) {
hOut = GetStdHandle(STD_ERROR_HANDLE);
}
else {
hOut = GetStdHandle(STD_OUTPUT_HANDLE);
}
if ((GetFileType(hOut) & ~FILE_TYPE_REMOTE) == FILE_TYPE_CHAR) {
DWORD cchWChar;
WCHAR szBufferMessage[1024];
vswprintf( szBufferMessage, format, argptr );
cchWChar = wcslen(szBufferMessage);
WriteConsoleW(hOut, szBufferMessage, cchWChar, &cchWChar, NULL);
return cchWChar;
}
return fwprintf(str, format, argptr);
}
///////////////////////////////////////////////////////////////////////////////
// This function is to suppress printf if the /quiet option is specified
///////////////////////////////////////////////////////////////////////////////
int __cdecl
My_printf(
const char *format,
...
)
{
int cchChar = 0;
va_list argptr;
va_start( argptr, format );
cchChar = printf(format, argptr);
va_end(argptr);
return cchChar;
}
///////////////////////////////////////////////////////////////////////////////
// This function takes the user string that is supplied at the command line
// and converts it into full path names for eg. it takes ..\%windir%\hisecws.inf
// and converts it to C:\winnt\security\templates\hisecws.inf
///////////////////////////////////////////////////////////////////////////////
WCHAR *
SecEditPConvertToFullPath(
WCHAR *pUserFilename,
DWORD *pRetCode
)
{
BOOL NeedCurrDirFlag = TRUE;
SCESTATUS rc;
DWORD Len;
DWORD LenCurrDir;
PWSTR pCurrentDir = NULL;
PWSTR pAbsolutePath = NULL;
PWSTR pAbsolutePathDirOnly = NULL;
PWSTR pToMerge = NULL;
PWSTR pLastSlash = NULL;
WCHAR FirstThree[4];
WCHAR LineString[256];
if (pUserFilename == NULL) {
*pRetCode = 2;
goto ScePathConvertFuncError;
}
// PathIsRoot() works only if exact strings
// such as C:\ are passed - so need to extract
wcsncpy(FirstThree, pUserFilename, 3);
FirstThree[3] = L'\0';
// if pUserFilename C:\ etc. then we do not need the current directory -
// Note: extraction hack not needed if PathIsRoot() worked as published
NeedCurrDirFlag = !PathIsRoot(FirstThree);
if (NeedCurrDirFlag){
LenCurrDir = GetCurrentDirectory(0, NULL);
pCurrentDir = (PWSTR)LocalAlloc(LMEM_ZEROINIT, (LenCurrDir+1)*sizeof(WCHAR));
if ( pCurrentDir == NULL ) {
rc = GetLastError();
LoadString( hMod,
SECEDITP_OUT_OF_MEMORY,
LineString,
256
);
SeceditpErrOut(rc, LineString );
*pRetCode = 2;
goto ScePathConvertFuncError;
}
GetCurrentDirectory(LenCurrDir, pCurrentDir);
if (pCurrentDir[LenCurrDir - 2] != L'\\')
wcscat(pCurrentDir, L"\\");
}
// allocate space for string that holds the to-be-expanded string
Len = wcslen(pUserFilename);
if (NeedCurrDirFlag)
Len += LenCurrDir;
pToMerge = (PWSTR)LocalAlloc(LMEM_ZEROINIT, (Len+1)*sizeof(WCHAR));
if ( pToMerge == NULL ) {
rc = GetLastError();
LoadString( hMod,
SECEDITP_OUT_OF_MEMORY,
LineString,
256
);
SeceditpErrOut(rc, LineString );
*pRetCode = 2;
goto ScePathConvertFuncError;
}
if (NeedCurrDirFlag)
wcscat(pToMerge, pCurrentDir);
wcscat(pToMerge, pUserFilename);
// allocate space for string that holds the final full path - can't be > wcslen(pToMerge)
#ifdef DBG
// shlwapi is lame on chk builds and verifies that the dest buffer is MAX_PATH
pAbsolutePath = (PWSTR)LocalAlloc(LMEM_ZEROINIT, MAX_PATH*sizeof(WCHAR));
#else
pAbsolutePath = (PWSTR)LocalAlloc(LMEM_ZEROINIT, (Len+1)*sizeof(WCHAR));
#endif
if ( pAbsolutePath == NULL ) {
rc = GetLastError();
LoadString( hMod,
SECEDITP_OUT_OF_MEMORY,
LineString,
256
);
SeceditpErrOut(rc, LineString );
*pRetCode = 2;
goto ScePathConvertFuncError;
}
// canonicalize pToMerge i.e. collapse all ..\, .\ and merge
if (PathCanonicalize(pAbsolutePath, pToMerge) == FALSE){
LoadString( hMod,
SECEDITP_PATH_NOT_CANONICALIZABLE,
LineString,
256
);
My_wprintf(LineString);
SCE_LOCAL_FREE(pAbsolutePath);
*pRetCode = 2;
goto ScePathConvertFuncError;
}
// allocate string to verify validity of directory
pAbsolutePathDirOnly = (PWSTR)LocalAlloc(LMEM_ZEROINIT, ((wcslen(pAbsolutePath)+1)*sizeof(WCHAR)));
if ( pAbsolutePathDirOnly == NULL ) {
rc = GetLastError();
LoadString( hMod,
SECEDITP_OUT_OF_MEMORY,
LineString,
256
);
SeceditpErrOut(rc, LineString );
SCE_LOCAL_FREE(pAbsolutePath);
*pRetCode = 2;
goto ScePathConvertFuncError;
}
// prepare pAbsolutePathDirOnly to have directory part only
wcscpy(pAbsolutePathDirOnly, pAbsolutePath);
pLastSlash = wcsrchr(pAbsolutePathDirOnly, L'\\');
if (pLastSlash)
*pLastSlash = L'\0';
if (PathIsDirectory(pAbsolutePathDirOnly) == FALSE){
LoadString( hMod,
SECEDITP_PATH_NOT_VALID,
LineString,
256
);
My_wprintf(L"\n%s - %s\n", LineString, pAbsolutePathDirOnly);
SCE_LOCAL_FREE(pAbsolutePath);
*pRetCode = 2;
goto ScePathConvertFuncError;
}
ScePathConvertFuncError:
SCE_LOCAL_FREE(pCurrentDir);
SCE_LOCAL_FREE(pToMerge);
SCE_LOCAL_FREE(pAbsolutePathDirOnly);
return pAbsolutePath;
}
///////////////////////////////////////////////////////////////////////////////
// This function opens the log file specified and saves the name and its handle
// in global variables
///////////////////////////////////////////////////////////////////////////////
BOOL
ScepCmdToolLogInit(
PWSTR logname
)
{
DWORD rc=NO_ERROR;
if ( logname && wcslen(logname) > 3 ) {
hCmdToolLogFile = CreateFile(logname,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( INVALID_HANDLE_VALUE != hCmdToolLogFile ) {
DWORD dwBytesWritten;
CHAR TmpBuf[3];
SetFilePointer (hCmdToolLogFile, 0, NULL, FILE_BEGIN);
TmpBuf[0] = (CHAR)0xFF;
TmpBuf[1] = (CHAR)0xFE;
TmpBuf[2] = '\0';
WriteFile (hCmdToolLogFile, (LPCVOID)TmpBuf, 2,
&dwBytesWritten,
NULL);
SetFilePointer (hCmdToolLogFile, 0, NULL, FILE_END);
}
} else {
hCmdToolLogFile = INVALID_HANDLE_VALUE;
}
if ( hCmdToolLogFile == INVALID_HANDLE_VALUE && (logname != NULL ) ) {
rc = ERROR_INVALID_NAME;
}
if ( INVALID_HANDLE_VALUE != hCmdToolLogFile ) {
CloseHandle( hCmdToolLogFile );
}
hCmdToolLogFile = INVALID_HANDLE_VALUE;
return(rc);
}
VOID
ScepCmdToolLogWrite(
PWSTR pErrString
)
{
DWORD cchWChar;
const TCHAR c_szCRLF[] = TEXT("\r\n");
if ( LogFile && wcslen(LogFile) > 3 ) {
hCmdToolLogFile = CreateFile(LogFile,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( INVALID_HANDLE_VALUE != hCmdToolLogFile ) {
SetFilePointer (hCmdToolLogFile, 0, NULL, FILE_END);
cchWChar = wcslen( pErrString );
WriteFile(hCmdToolLogFile,
(LPCVOID)pErrString,
sizeof(WCHAR) * cchWChar,
&cchWChar,
NULL);
WriteFile (hCmdToolLogFile, (LPCVOID) c_szCRLF,
2 * sizeof(WCHAR),
&cchWChar,
NULL);
// SetFilePointer (hCmdToolLogFile, 0, NULL, FILE_END);
CloseHandle( hCmdToolLogFile );
hCmdToolLogFile = INVALID_HANDLE_VALUE;
return;
}
}
}
///////////////////////////////////////////////////////////////////////////////
// This function closes the log file if there is one opened and
// clears the log variables
///////////////////////////////////////////////////////////////////////////////
SCESTATUS
ScepCmdToolLogClose()
{
if ( INVALID_HANDLE_VALUE != hCmdToolLogFile ) {
CloseHandle( hCmdToolLogFile );
}
hCmdToolLogFile = INVALID_HANDLE_VALUE;
return(SCESTATUS_SUCCESS);
}
Reference in a new issue Copy permalink