[REG_ERROR] RegCloseKey(HKEY hKey);
[REG_ERROR] RegConnectRegistry(LPCTSTR lpMachineName,HKEY hKey,PHKEY phkResult);
[REG_ERROR] RegCopyTree(HKEY hKeySrc,LPCTSTR lpSubKey,HKEY hKeyDest);
[REG_ERROR] RegCreateKeyEx(HKEY hKey,LPCTSTR lpSubKey,DWORD Reserved,LPTSTR lpClass,[RegOptions] dwOptions,REGSAM samDesired,LPSECURITY_ATTRIBUTES lpSecurityAttributes,PHKEY phkResult,[RegDisposition*] lpdwDisposition);
[REG_ERROR] RegCreateKeyTransacted(HKEY hKey,LPCTSTR lpSubKey,DWORD Reserved,LPTSTR lpClass,[RegOptions] dwOptions,REGSAM samDesired,const LPSECURITY_ATTRIBUTES lpSecurityAttributes,PHKEY phkResult,[RegDisposition*] lpdwDisposition,HANDLE hTransaction,PVOID pExtendedParemeter);
[REG_ERROR] RegDeleteKey(HKEY hKey,LPCTSTR lpSubKey);
[REG_ERROR] RegDeleteKeyEx(HKEY hKey,LPCTSTR lpSubKey,REGSAM samDesired,DWORD Reserved);
[REG_ERROR] RegDeleteKeyTransacted(HKEY hKey,LPCTSTR lpSubKey,REGSAM samDesired,DWORD Reserved,HANDLE hTransaction,PVOID pExtendedParameter);
[REG_ERROR] RegDeleteKeyValue(HKEY hKey,LPCTSTR lpSubKey,LPCTSTR lpValueName);
[REG_ERROR] RegDeleteTree(HKEY hKey,LPCTSTR lpSubKey);
[REG_ERROR] RegDeleteValue(HKEY hKey,LPCTSTR lpValueName);
[REG_ERROR] RegDisablePredefinedCache();
[REG_ERROR] RegDisablePredefinedCacheEx();
[REG_ERROR] RegDisableReflectionKey(HKEY hBase);
[REG_ERROR] RegEnableReflectionKey(HKEY hBase);
[REG_ERROR] RegEnumKeyEx(HKEY hKey,DWORD dwIndex,LPTSTR lpName,LPDWORD lpcName,LPDWORD lpReserved,LPTSTR lpClass,LPDWORD lpcClass,PFILETIME lpftLastWriteTime);
[REG_ERROR] RegEnumValue(HKEY hKey,DWORD dwIndex,LPTSTR lpValueName,LPDWORD lpcchValueName,LPDWORD lpReserved,[RegType*] lpType,LPBYTE lpData,LPDWORD lpcbData);
[REG_ERROR] RegFlushKey(HKEY hKey);
[REG_ERROR] RegGetValue(HKEY hkey,LPCTSTR lpSubKey,LPCTSTR lpValue,DWORD dwFlags,[RegType*] pdwType,PVOID pvData,LPDWORD pcbData);
[REG_ERROR] RegLoadAppKey(LPCTSTR lpFile,PHKEY phkResult,REGSAM samDesired,[RegLoadAppKey_Options] dwOptions,DWORD Reserved);
[REG_ERROR] RegLoadKey(HKEY hKey,LPCTSTR lpSubKey,LPCTSTR lpFile);
[REG_ERROR] RegLoadMUIString(HKEY hKey,LPCTSTR pszValue,LPTSTR pszOutBuf,DWORD cbOutBuf,LPDWORD pcbData,[RegMuiFlags] Flags,LPCTSTR pszDirectory);
[REG_ERROR] RegNotifyChangeKeyValue(HKEY hKey,BOOL bWatchSubtree,[RegNotifyFlags] dwNotifyFilter,HANDLE hEvent,BOOL fAsynchronous);
[REG_ERROR] RegOpenCurrentUser(REGSAM samDesired,PHKEY phkResult);
[REG_ERROR] RegOpenKeyEx(HKEY hKey,LPCTSTR lpSubKey,DWORD ulOptions,REGSAM samDesired,PHKEY phkResult);
[REG_ERROR] RegOpenKeyTransacted(HKEY hKey,LPCTSTR lpSubKey,DWORD ulOptions,REGSAM samDesired,PHKEY phkResult,HANDLE hTransaction,PVOID pExtendedParameter);
[REG_ERROR] RegOpenUserClassesRoot(HANDLE hToken,DWORD dwOptions,REGSAM samDesired,PHKEY phkResult);
[REG_ERROR] RegOverridePredefKey(HKEY hKey,HKEY hNewHKey);
[REG_ERROR] RegQueryInfoKey(HKEY hKey,LPTSTR lpClass,LPDWORD lpcClass,LPDWORD lpReserved,LPDWORD lpcSubKeys,LPDWORD lpcMaxSubKeyLen,LPDWORD lpcMaxClassLen,LPDWORD lpcValues,LPDWORD lpcMaxValueNameLen,LPDWORD lpcMaxValueLen,LPDWORD lpcbSecurityDescriptor,PFILETIME lpftLastWriteTime);
[REG_ERROR] RegQueryMultipleValues(HKEY hKey,PVALENT val_list,DWORD num_vals,LPVOID lpValueBuf,LPDWORD ldwTotsize);
[REG_ERROR] RegQueryReflectionKey(HKEY hBase,BOOL* bIsReflectionDisabled);
[REG_ERROR] RegQueryValueEx(HKEY hKey,LPCTSTR lpValueName,LPDWORD lpReserved,[RegType*] lpType,LPBYTE lpData,LPDWORD lpcbData);
[REG_ERROR] RegReplaceKey(HKEY hKey,LPCTSTR lpSubKey,LPCTSTR lpNewFile,LPCTSTR lpOldFile);
[REG_ERROR] RegRestoreKey(HKEY hKey,LPCTSTR lpFile,DWORD dwFlags);
[REG_ERROR] RegSaveKey(HKEY hKey,LPCTSTR lpFile,LPSECURITY_ATTRIBUTES lpSecurityAttributes);
[REG_ERROR] RegSaveKeyEx(HKEY hKey,LPCTSTR lpFile,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD Flags);
[REG_ERROR] RegSetKeyValue(HKEY hKey,LPCTSTR lpSubKey,LPCTSTR lpValueName,[RegType] dwType,LPCVOID lpData,DWORD cbData);
[REG_ERROR] RegSetValueEx(HKEY hKey,LPCTSTR lpValueName,DWORD Reserved,[RegType] dwType,const BYTE* lpData,DWORD cbData);
[REG_ERROR] RegUnLoadKey(HKEY hKey,LPCTSTR lpSubKey);
[REG_ERROR] RegCreateKey(HKEY hKey,LPCTSTR lpSubKey,PHKEY phkResult);
[REG_ERROR] RegEnumKey(HKEY hKey,DWORD dwIndex,LPTSTR lpName,DWORD cchName);
[REG_ERROR] RegOpenKey(HKEY hKey,LPCTSTR lpSubKey,PHKEY phkResult);
[REG_ERROR] RegQueryValue(HKEY hKey,LPCTSTR lpSubKey,LPTSTR lpValue,PLONG lpcbValue);
[REG_ERROR] RegSetValue(HKEY hKey,LPCTSTR lpSubKey,[RegType] dwType,LPCTSTR lpData,DWORD cbData);
[ERROR_CODE] AddUsersToEncryptedFile(LPCWSTR lpFileName,PENCRYPTION_CERTIFICATE_LIST pUsers);
void CloseEncryptedFileRaw(PVOID pvContext);
BOOL DecryptFile(LPCTSTR lpFileName,DWORD dwReserved);
[ERROR_CODE] DuplicateEncryptionInfoFile(LPCTSTR SrcFileName,LPCTSTR DstFileName,DWORD dwCreationDistribution,DWORD dwAttributes,const LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL EncryptFile(LPCTSTR lpFileName);
BOOL EncryptionDisable(LPCWSTR DirPath,BOOL Disable);
BOOL FileEncryptionStatus(LPCTSTR lpFileName,LPDWORD lpStatus);
void FreeEncryptionCertificateHashList(PENCRYPTION_CERTIFICATE_HASH_LIST pHashes);
[ERROR_CODE] OpenEncryptedFileRaw(LPCTSTR lpFileName,ULONG ulFlags,PVOID* pvContext);
[ERROR_CODE] QueryRecoveryAgentsOnEncryptedFile(LPCWSTR lpFileName,PENCRYPTION_CERTIFICATE_HASH_LIST* pRecoveryAgents);
[ERROR_CODE] QueryUsersOnEncryptedFile(LPCWSTR lpFileName,PENCRYPTION_CERTIFICATE_HASH_LIST* pUsers);
[ERROR_CODE] ReadEncryptedFileRaw(PFE_EXPORT_FUNC pfExportCallback,PVOID pvCallbackContext,PVOID pvContext);
[ERROR_CODE] RemoveUsersFromEncryptedFile(LPCWSTR lpFileName,PENCRYPTION_CERTIFICATE_HASH_LIST pHashes);
[ERROR_CODE] SetUserFileEncryptionKey(PENCRYPTION_CERTIFICATE pEncryptionCertificate);
[ERROR_CODE] WriteEncryptedFileRaw(PFE_IMPORT_FUNC pfImportCallback,PVOID pvCallbackContext,PVOID pvContext);
BOOL CreateProcessAsUser(HANDLE hToken,LPCTSTR lpApplicationName,LPTSTR lpCommandLine,LPSECURITY_ATTRIBUTES lpProcessAttributes,LPSECURITY_ATTRIBUTES lpThreadAttributes,BOOL bInheritHandles,[CreateProcessFlags] dwCreationFlags,LPVOID lpEnvironment,LPCTSTR lpCurrentDirectory,LPSTARTUPINFO lpStartupInfo,LPPROCESS_INFORMATION lpProcessInformation);
BOOL CreateProcessWithLogonW(LPCWSTR lpUsername,LPCWSTR lpDomain,LPCWSTR lpPassword,[LogonFlags] dwLogonFlags,LPCWSTR lpApplicationName,LPWSTR lpCommandLine,[CreateProcessFlags] dwCreationFlags,LPVOID lpEnvironment,LPCWSTR lpCurrentDirectory,LPSTARTUPINFOW lpStartupInfo,LPPROCESS_INFORMATION lpProcessInfo);
BOOL CreateProcessWithTokenW(HANDLE hToken,[LogonFlags] dwLogonFlags,LPCWSTR lpApplicationName,LPWSTR lpCommandLine,[CreateProcessFlags] dwCreationFlags,LPVOID lpEnvironment,LPCWSTR lpCurrentDirectory,LPSTARTUPINFOW lpStartupInfo,LPPROCESS_INFORMATION lpProcessInfo);
[ERROR_CODE] GetLocalManagedApplications(BOOL bUserApps,LPDWORD pdwApps,PLOCALMANAGEDAPPLICATION* prgLocalApps);
[ERROR_CODE] GetManagedApplications(GUID* pCategory,DWORD dwQueryFlags,DWORD dwInfoLevel,LPDWORD pdwApps,PMANAGEDAPPLICATION* prgManagedApps);
[ERROR_CODE] GetManagedApplicationCategories(DWORD dwReserved,APPCATEGORYINFOLIST* pAppCategory);
[ERROR_CODE] InstallApplication(PINSTALLDATA* pInstallInfo);
[ERROR_CODE] UninstallApplication(WCHAR* ProductCode,DWORD dwStatus);
BOOL AbortSystemShutdown(LPTSTR lpMachineName);
[ERROR_CODE] InitiateShutdown(LPTSTR lpMachineName,LPTSTR lpMessage,DWORD dwGracePeriod,[SHUTDOWN_FLAGS] dwShutdownFlags,[SHTDN_REASON] dwReason);
BOOL InitiateSystemShutdown(LPTSTR lpMachineName,LPTSTR lpMessage,DWORD dwTimeout,BOOL bForceAppsClosed,BOOL bRebootAfterShutdown);
BOOL InitiateSystemShutdownEx(LPTSTR lpMachineName,LPTSTR lpMessage,DWORD dwTimeout,BOOL bForceAppsClosed,BOOL bRebootAfterShutdown,[SHTDN_REASON] dwReason);
BOOL BackupEventLog(HANDLE hEventLog,LPCTSTR lpBackupFileName);
BOOL ClearEventLog(HANDLE hEventLog,LPCTSTR lpBackupFileName);
BOOL CloseEventLog(HANDLE hEventLog);
BOOL DeregisterEventSource(HANDLE hEventLog);
BOOL GetEventLogInformation(HANDLE hEventLog,DWORD dwInfoLevel,LPVOID lpBuffer,DWORD cbBufSize,LPDWORD pcbBytesNeeded);
BOOL GetNumberOfEventLogRecords(HANDLE hEventLog,PDWORD NumberOfRecords);
BOOL GetOldestEventLogRecord(HANDLE hEventLog,PDWORD OldestRecord);
BOOL NotifyChangeEventLog(HANDLE hEventLog,HANDLE hEvent);
HANDLE OpenBackupEventLog(LPCTSTR lpUNCServerName,LPCTSTR lpFileName);
HANDLE OpenEventLog(LPCTSTR lpUNCServerName,LPCTSTR lpSourceName);
BOOL ReadEventLog(HANDLE hEventLog,DWORD dwReadFlags,DWORD dwRecordOffset,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,DWORD* pnBytesRead,DWORD* pnMinNumberOfBytesNeeded);
HANDLE RegisterEventSource(LPCTSTR lpUNCServerName,LPCTSTR lpSourceName);
BOOL ReportEvent(HANDLE hEventLog,[EventLogType] wType,WORD wCategory,DWORD dwEventID,PSID lpUserSid,WORD wNumStrings,DWORD dwDataSize,LPCTSTR* lpStrings,LPVOID lpRawData);
PPERF_COUNTERSET_INSTANCE PerfCreateInstance(HANDLE hProvider,LPCGUID CounterSetGuid,LPCWSTR szInstanceName,ULONG dwInstance);
[ERROR_CODE_ULONG] PerfDecrementULongCounterValue(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE pInstance,ULONG CounterId,ULONG lValue);
[ERROR_CODE_ULONG] PerfDecrementULongLongCounterValue(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE pInstance,ULONG CounterId,ULONGLONG llValue);
[ERROR_CODE_ULONG] PerfDeleteInstance(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE InstanceBlock);
[ERROR_CODE_ULONG] PerfIncrementULongCounterValue(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE pInstance,ULONG CounterId,ULONG lValue);
[ERROR_CODE_ULONG] PerfIncrementULongLongCounterValue(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE pInstance,ULONG CounterId,ULONGLONG llValue);
PPERF_COUNTERSET_INSTANCE PerfQueryInstance(HANDLE hProvider,LPCGUID CounterSetGuid,LPCWSTR szInstance,ULONG dwInstance);
[ERROR_CODE_ULONG] PerfSetCounterSetInfo(HANDLE hProvider,PPERF_COUNTERSET_INFO pTemplate,ULONG dwTemplateSize);
[ERROR_CODE_ULONG] PerfSetULongCounterValue(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE pInstance,ULONG CounterId,ULONG lValue);
[ERROR_CODE_ULONG] PerfSetULongLongCounterValue(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE pInstance,ULONG CounterId,ULONGLONG llValue);
[ERROR_CODE_ULONG] PerfSetCounterRefValue(HANDLE hProvider,PPERF_COUNTERSET_INSTANCE pInstance,ULONG CounterId,PVOID lpAddr);
[ERROR_CODE_ULONG] PerfStartProvider(LPGUID ProviderGuid,PERFLIBREQUEST ControlCallback,HANDLE* phProvider);
[ERROR_CODE_ULONG] PerfStartProviderEx(LPGUID ProviderGuid,PPERF_PROVIDER_CONTEXT ProviderContext,HANDLE* phProvider);
[ERROR_CODE_ULONG] PerfStopProvider(HANDLE hProvider);
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandler(LPCTSTR lpServiceName,LPHANDLER_FUNCTION lpHandlerProc);
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerEx(LPCTSTR lpServiceName,LPHANDLER_FUNCTION_EX lpHandlerProc,LPVOID lpContext);
BOOL SetServiceBits(SERVICE_STATUS_HANDLE hServiceStatus,DWORD dwServiceBits,BOOL bSetBitsOn,BOOL bUpdateImmediately);
BOOL SetServiceStatus(SERVICE_STATUS_HANDLE hServiceStatus,LPSERVICE_STATUS lpServiceStatus);
BOOL StartServiceCtrlDispatcher(const SERVICE_TABLE_ENTRY* lpServiceTable);
BOOL ChangeServiceConfig(SC_HANDLE hService,[ServiceType] dwServiceType,[ServiceStartType] dwStartType,[ServiceErrorControl] dwErrorControl,LPCTSTR lpBinaryPathName,LPCTSTR lpLoadOrderGroup,LPDWORD lpdwTagId,LPCTSTR lpDependencies,LPCTSTR lpServiceStartName,LPCTSTR lpPassword,LPCTSTR lpDisplayName);
BOOL ChangeServiceConfig2(SC_HANDLE hService,[ServiceInfoLevel] dwInfoLevel,LPVOID lpInfo);
BOOL CloseServiceHandle(SC_HANDLE hSCObject);
BOOL ControlService(SC_HANDLE hService,[ServiceControl] dwControl,LPSERVICE_STATUS lpServiceStatus);
BOOL ControlServiceEx(SC_HANDLE hService,DWORD dwControl,DWORD dwInfoLevel,PVOID pControlParams);
SC_HANDLE CreateService(SC_HANDLE hSCManager,LPCTSTR lpServiceName,LPCTSTR lpDisplayName,[ServiceAccess] dwDesiredAccess,[ServiceType] dwServiceType,[ServiceStartType] dwStartType,[ServiceErrorControl] dwErrorControl,LPCTSTR lpBinaryPathName,LPCTSTR lpLoadOrderGroup,LPDWORD lpdwTagId,LPCTSTR lpDependencies,LPCTSTR lpServiceStartName,LPCTSTR lpPassword);
BOOL DeleteService(SC_HANDLE hService);
BOOL EnumDependentServices(SC_HANDLE hService,[ServiceState] dwServiceState,LPENUM_SERVICE_STATUS lpServices,DWORD cbBufSize,LPDWORD pcbBytesNeeded,LPDWORD lpServicesReturned);
BOOL EnumServicesStatusEx(SC_HANDLE hSCManager,SC_ENUM_TYPE InfoLevel,[ServiceType] dwServiceType,[ServiceState] dwServiceState,LPBYTE lpServices,DWORD cbBufSize,LPDWORD pcbBytesNeeded,LPDWORD lpServicesReturned,LPDWORD lpResumeHandle,LPCTSTR pszGroupName);
BOOL GetServiceDisplayName(SC_HANDLE hSCManager,LPCTSTR lpServiceName,LPTSTR lpDisplayName,LPDWORD lpcchBuffer);
BOOL GetServiceKeyName(SC_HANDLE hSCManager,LPCTSTR lpDisplayName,LPTSTR lpServiceName,LPDWORD lpcchBuffer);
BOOL NotifyBootConfigStatus(BOOL BootAcceptable);
[ERROR_CODE] NotifyServiceStatusChange(SC_HANDLE hService,[ServiceNotifyMask] dwNotifyMask,PSERVICE_NOTIFYA pNotifyBuffer);
[ERROR_CODE] NotifyServiceStatusChange(SC_HANDLE hService,[ServiceNotifyMask] dwNotifyMask,PSERVICE_NOTIFY pNotifyBuffer);
SC_HANDLE OpenSCManager(LPCTSTR lpMachineName,LPCTSTR lpDatabaseName,[SCManagerAccess] dwDesiredAccess);
SC_HANDLE OpenService(SC_HANDLE hSCManager,LPCTSTR lpServiceName,[ServiceAccess] dwDesiredAccess);
BOOL QueryServiceConfig(SC_HANDLE hService,LPQUERY_SERVICE_CONFIG lpServiceConfig,DWORD cbBufSize,LPDWORD pcbBytesNeeded);
BOOL QueryServiceConfig2(SC_HANDLE hService,[ServiceInfoLevel] dwInfoLevel,LPBYTE lpBuffer,DWORD cbBufSize,LPDWORD pcbBytesNeeded);
BOOL QueryServiceDynamicInformation(SERVICE_STATUS_HANDLE hServiceStatus,DWORD dwInfoLevel,PVOID* ppDynamicInfo);
BOOL QueryServiceStatus(SC_HANDLE hService,LPSERVICE_STATUS lpServiceStatus);
BOOL QueryServiceStatusEx(SC_HANDLE hService,SC_STATUS_TYPE InfoLevel,LPBYTE lpBuffer,DWORD cbBufSize,LPDWORD pcbBytesNeeded);
BOOL StartService(SC_HANDLE hService,DWORD dwNumServiceArgs,LPCTSTR* lpServiceArgVectors);
BOOL EnumServicesStatus(SC_HANDLE hSCManager,[ServiceType] dwServiceType,[ServiceState] dwServiceState,LPENUM_SERVICE_STATUS lpServices,DWORD cbBufSize,LPDWORD pcbBytesNeeded,LPDWORD lpServicesReturned,LPDWORD lpResumeHandle);
SC_LOCK LockServiceDatabase(SC_HANDLE hSCManager);
BOOL QueryServiceLockStatus(SC_HANDLE hSCManager,LPQUERY_SERVICE_LOCK_STATUS lpLockStatus,DWORD cbBufSize,LPDWORD pcbBytesNeeded);
BOOL UnlockServiceDatabase(SC_LOCK ScLock);
BOOL GetCurrentHwProfile(LPHW_PROFILE_INFO lpHwProfileInfo);
BOOL GetUserName(LPTSTR lpBuffer,LPDWORD lpnSize);
BOOL IsTextUnicode(const VOID* lpv,int iSize,[IsTextUnicodeFlags*] lpiResult);
BOOL CryptAcquireContext(HCRYPTPROV* phProv,LPCTSTR pszContainer,LPCTSTR pszProvider,[CryptProv] dwProvType,[CryptAcquireContextFlags] dwFlags);
BOOL CryptContextAddRef(HCRYPTPROV hProv,DWORD* pdwReserved,DWORD dwFlags);
BOOL CryptEnumProviders(DWORD dwIndex,DWORD* pdwReserved,DWORD dwFlags,[CryptProv*] pdwProvType,LPTSTR pszProvName,DWORD* pcbProvName);
BOOL CryptEnumProviderTypes(DWORD dwIndex,DWORD* pdwReserved,DWORD dwFlags,[CryptProv*] pdwProvType,LPTSTR pszTypeName,DWORD* pcbTypeName);
BOOL CryptGetDefaultProvider([CryptProv] dwProvType,DWORD* pdwReserved,DWORD dwFlags,LPTSTR pszProvName,DWORD* pcbProvName);
BOOL CryptGetProvParam(HCRYPTPROV hProv,[CryptGetProvParam] dwParam,BYTE* pbData,DWORD* pdwDataLen,DWORD dwFlags);
BOOL CryptReleaseContext(HCRYPTPROV hProv,DWORD dwFlags);
BOOL CryptSetProvider(LPCTSTR pszProvName,[CryptProv] dwProvType);
BOOL CryptSetProviderEx(LPCTSTR pszProvName,[CryptProv] dwProvType,DWORD* pdwReserved,DWORD dwFlags);
BOOL CryptSetProvParam(HCRYPTPROV hProv,[CryptSetProvParam] dwParam,const BYTE* pbData,DWORD dwFlags);
BOOL CryptDeriveKey(HCRYPTPROV hProv,ALG_ID Algid,HCRYPTHASH hBaseData,DWORD dwFlags,HCRYPTKEY* phKey);
BOOL CryptDestroyKey(HCRYPTKEY hKey);
BOOL CryptDuplicateKey(HCRYPTKEY hKey,DWORD* pdwReserved,DWORD dwFlags,HCRYPTKEY* phKey);
BOOL CryptExportKey(HCRYPTKEY hKey,HCRYPTKEY hExpKey,[CryptBlobType] dwBlobType,[CryptExportKeyFlags] dwFlags,BYTE* pbData,DWORD* pdwDataLen);
BOOL CryptGenKey(HCRYPTPROV hProv,ALG_ID Algid,DWORD dwFlags,HCRYPTKEY* phKey);
BOOL CryptGenRandom(HCRYPTPROV hProv,DWORD dwLen,BYTE* pbBuffer);
BOOL CryptGetKeyParam(HCRYPTKEY hKey,[CryptKeyParam] dwParam,BYTE* pbData,DWORD* pdwDataLen,DWORD dwFlags);
BOOL CryptGetUserKey(HCRYPTPROV hProv,[CryptKeySpec] dwKeySpec,HCRYPTKEY* phUserKey);
BOOL CryptImportKey(HCRYPTPROV hProv,BYTE* pbData,DWORD dwDataLen,HCRYPTKEY hPubKey,[CryptImportKeyFlags] dwFlags,HCRYPTKEY* phKey);
BOOL CryptSetKeyParam(HCRYPTKEY hKey,[CryptKeyParam] dwParam,const BYTE* pbData,DWORD dwFlags);
BOOL CryptDecrypt(HCRYPTKEY hKey,HCRYPTHASH hHash,BOOL Final,DWORD dwFlags,BYTE* pbData,DWORD* pdwDataLen);
BOOL CryptEncrypt(HCRYPTKEY hKey,HCRYPTHASH hHash,BOOL Final,DWORD dwFlags,BYTE* pbData,DWORD* pdwDataLen,DWORD dwBufLen);
BOOL CryptCreateHash(HCRYPTPROV hProv,ALG_ID Algid,HCRYPTKEY hKey,[CryptCreateHashFlags] dwFlags,HCRYPTHASH* phHash);
BOOL CryptDestroyHash(HCRYPTHASH hHash);
BOOL CryptDuplicateHash(HCRYPTHASH hHash,DWORD* pdwReserved,DWORD dwFlags,HCRYPTHASH* phHash);
BOOL CryptGetHashParam(HCRYPTHASH hHash,[CryptHashParam] dwParam,BYTE* pbData,DWORD* pdwDataLen,DWORD dwFlags);
BOOL CryptHashData(HCRYPTHASH hHash,BYTE* pbData,DWORD dwDataLen,[CryptHashDataFlags] dwFlags);
BOOL CryptHashSessionKey(HCRYPTHASH hHash,HCRYPTKEY hKey,DWORD dwFlags);
BOOL CryptSetHashParam(HCRYPTHASH hHash,[CryptHashParam] dwParam,const BYTE* pbData,DWORD dwFlags);
BOOL CryptSignHash(HCRYPTHASH hHash,[CryptKeySpec] dwKeySpec,LPCTSTR sDescription,[CryptSignFlags] dwFlags,BYTE* pbSignature,DWORD* pdwSigLen);
BOOL CryptVerifySignature(HCRYPTHASH hHash,BYTE* pbSignature,DWORD dwSigLen,HCRYPTKEY hPubKey,LPCTSTR sDescription,[CryptSignFlags] dwFlags);
[ERROR_CODE_ULONG] ControlTrace(TRACEHANDLE SessionHandle,LPCTSTR SessionName,PEVENT_TRACE_PROPERTIES Properties,ULONG ControlCode);
[ERROR_CODE_ULONG] EnableTrace(ULONG Enable,ULONG EnableFlag,ULONG EnableLevel,LPCGUID ControlGuid,TRACEHANDLE SessionHandle);
[ERROR_CODE_ULONG] EnableTraceEx(LPCGUID ProviderId,LPCGUID SourceId,TRACEHANDLE TraceHandle,ULONG IsEnabled,UCHAR Level,ULONGLONG MatchAnyKeyword,ULONGLONG MatchAllKeyword,ULONG EnableProperty,PEVENT_FILTER_DESCRIPTOR EnableFilterDesc);
[ERROR_CODE_ULONG] EnableTraceEx2(TRACEHANDLE TraceHandle,LPCGUID ProviderId,ULONG ControlCode,UCHAR Level,ULONGLONG MatchAnyKeyword,ULONGLONG MatchAllKeyword,ULONG Timeout,PENABLE_TRACE_PARAMETERS EnableParameters);
[ERROR_CODE_ULONG] EnumerateTraceGuids(PTRACE_GUID_PROPERTIES* GuidPropertiesArray,ULONG PropertyArrayCount,PULONG GuidCount);
[ERROR_CODE_ULONG] EnumerateTraceGuidsEx(TRACE_QUERY_INFO_CLASS TraceQueryInfoClass,PVOID InBuffer,ULONG InBufferSize,PVOID OutBuffer,ULONG OutBufferSize,PULONG ReturnLength);
[ERROR_CODE_ULONG] FlushTrace(TRACEHANDLE SessionHandle,LPCTSTR SessionName,PEVENT_TRACE_PROPERTIES Properties);
[ERROR_CODE_ULONG] QueryAllTraces(PEVENT_TRACE_PROPERTIES* PropertyArray,ULONG PropertyArrayCount,PULONG SessionCount);
[ERROR_CODE_ULONG] QueryTrace(TRACEHANDLE SessionHandle,LPCTSTR SessionName,PEVENT_TRACE_PROPERTIES Properties);
[ERROR_CODE_ULONG] StartTrace(PTRACEHANDLE SessionHandle,LPCTSTR SessionName,PEVENT_TRACE_PROPERTIES Properties);
[ERROR_CODE_ULONG] StopTrace(TRACEHANDLE SessionHandle,LPCTSTR SessionName,PEVENT_TRACE_PROPERTIES Properties);
[ERROR_CODE_ULONG] TraceQueryInformation(TRACEHANDLE SessionHandle,TRACE_QUERY_INFO_CLASS InformationClass,PVOID TraceInformation,ULONG InformationLength,PULONG ReturnLength);
[ERROR_CODE_ULONG] TraceSetInformation(TRACEHANDLE SessionHandle,TRACE_INFO_CLASS InformationClass,PVOID TraceInformation,ULONG InformationLength);
[ERROR_CODE_ULONG] UpdateTrace(TRACEHANDLE SessionHandle,LPCTSTR SessionName,PEVENT_TRACE_PROPERTIES Properties);
[ERROR_CODE_ULONG] CreateTraceInstanceId(HANDLE RegHandle,PEVENT_INSTANCE_INFO pInstInfo);
[ERROR_CODE_ULONG] GetTraceEnableFlags(TRACEHANDLE SessionHandle);
UCHAR GetTraceEnableLevel(TRACEHANDLE SessionHandle);
TRACEHANDLE GetTraceLoggerHandle(PVOID Buffer);
[ERROR_CODE_ULONG] RegisterTraceGuids(WMIDPREQUEST RequestAddress,PVOID RequestContext,LPCGUID ControlGuid,ULONG GuidCount,PTRACE_GUID_REGISTRATION TraceGuidReg,LPCTSTR MofImagePath,LPCTSTR MofResourceName,PTRACEHANDLE RegistrationHandle);
[ERROR_CODE_ULONG] TraceEvent(TRACEHANDLE SessionHandle,PEVENT_TRACE_HEADER EventTrace);
[ERROR_CODE_ULONG] TraceEventInstance(TRACEHANDLE SessionHandle,PEVENT_INSTANCE_HEADER EventTrace,PEVENT_INSTANCE_INFO pInstInfo,PEVENT_INSTANCE_INFO pParentInstInfo);
[ERROR_CODE_ULONG] TraceMessage(TRACEHANDLE SessionHandle,[TRACE_MESSAGE_FLAGS] MessageFlags,LPGUID MessageGuid,USHORT MessageNumber);
[ERROR_CODE_ULONG] TraceMessageVa(TRACEHANDLE SessionHandle,ULONG MessageFlags,LPGUID MessageGuid,USHORT MessageNumber,va_list MessageArgList);
[ERROR_CODE_ULONG] UnregisterTraceGuids(TRACEHANDLE RegistrationHandle);
[ERROR_CODE_ULONG] EventActivityIdControl([EventActivity] ControlCode,LPGUID ActivityId);
BOOLEAN EventEnabled(REGHANDLE RegHandle,PCEVENT_DESCRIPTOR EventDescriptor);
BOOLEAN EventProviderEnabled(REGHANDLE RegHandle,UCHAR Level,ULONGLONG Keyword);
[ERROR_CODE_ULONG] EventRegister(LPCGUID ProviderId,ENABLECALLBACK EnableCallback,PVOID CallbackContext,PREGHANDLE RegHandle);
[ERROR_CODE_ULONG] EventSetInformation(REGHANDLE RegHandle,EVENT_INFO_CLASS InformationClass,PVOID EventInformation,ULONG InformationLength);
[ERROR_CODE_ULONG] EventUnregister(REGHANDLE RegHandle);
[ERROR_CODE_ULONG] EventWrite(REGHANDLE RegHandle,PCEVENT_DESCRIPTOR EventDescriptor,ULONG UserDataCount,PEVENT_DATA_DESCRIPTOR UserData);
[ERROR_CODE_ULONG] EventWriteEx(REGHANDLE RegHandle,PCEVENT_DESCRIPTOR EventDescriptor,ULONG64 Filter,ULONG Flags,LPCGUID ActivityId,LPCGUID RelatedActivityId,ULONG UserDataCount,PEVENT_DATA_DESCRIPTOR UserData);
[ERROR_CODE_ULONG] EventWriteString(REGHANDLE RegHandle,UCHAR Level,ULONGLONG Keyword,PCWSTR String);
[ERROR_CODE_ULONG] EventWriteTransfer(REGHANDLE RegHandle,PCEVENT_DESCRIPTOR EventDescriptor,LPCGUID ActivityId,LPCGUID RelatedActivityId,ULONG UserDataCount,PEVENT_DATA_DESCRIPTOR UserData);
[ERROR_CODE_ULONG] CloseTrace(TRACEHANDLE TraceHandle);
TRACEHANDLE OpenTrace(PEVENT_TRACE_LOGFILE Logfile);
[ERROR_CODE_ULONG] ProcessTrace(PTRACEHANDLE HandleArray,ULONG HandleCount,LPFILETIME StartTime,LPFILETIME EndTime);
[ERROR_CODE_ULONG] RemoveTraceCallback(LPCGUID pGuid);
[ERROR_CODE_ULONG] SetTraceCallback(LPCGUID pGuid,PEVENT_CALLBACK EventCallback);
[ERROR_CODE_ULONG] EventAccessControl(LPGUID Guid,ULONG Operation,PSID Sid,ULONG Rights,BOOLEAN AllowOrDeny);
[ERROR_CODE_ULONG] EventAccessQuery(LPGUID Guid,PSECURITY_DESCRIPTOR Buffer,PULONG BufferSize);
[ERROR_CODE_ULONG] EventAccessRemove(LPGUID Guid);
BOOL AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor,HANDLE ClientToken,DWORD DesiredAccess,PGENERIC_MAPPING GenericMapping,PPRIVILEGE_SET PrivilegeSet,LPDWORD PrivilegeSetLength,LPDWORD GrantedAccess,LPBOOL AccessStatus);
BOOL AccessCheckByType(PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID PrincipalSelfSid,HANDLE ClientToken,DWORD DesiredAccess,POBJECT_TYPE_LIST ObjectTypeList,DWORD ObjectTypeListLength,PGENERIC_MAPPING GenericMapping,PPRIVILEGE_SET PrivilegeSet,LPDWORD PrivilegeSetLength,LPDWORD GrantedAccess,LPBOOL AccessStatus);
BOOL AccessCheckByTypeResultList(PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID PrincipalSelfSid,HANDLE ClientToken,DWORD DesiredAccess,POBJECT_TYPE_LIST ObjectTypeList,DWORD ObjectTypeListLength,PGENERIC_MAPPING GenericMapping,PPRIVILEGE_SET PrivilegeSet,LPDWORD PrivilegeSetLength,LPDWORD GrantedAccessList,LPDWORD AccessStatusList);
BOOL AdjustTokenGroups(HANDLE TokenHandle,BOOL ResetToDefault,PTOKEN_GROUPS NewState,DWORD BufferLength,PTOKEN_GROUPS PreviousState,PDWORD ReturnLength);
BOOL AdjustTokenPrivileges(HANDLE TokenHandle,BOOL DisableAllPrivileges,PTOKEN_PRIVILEGES NewState,DWORD BufferLength,PTOKEN_PRIVILEGES PreviousState,PDWORD ReturnLength);
BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,BYTE nSubAuthorityCount,DWORD dwSubAuthority0,DWORD dwSubAuthority1,DWORD dwSubAuthority2,DWORD dwSubAuthority3,DWORD dwSubAuthority4,DWORD dwSubAuthority5,DWORD dwSubAuthority6,DWORD dwSubAuthority7,PSID* pSid);
BOOL AllocateLocallyUniqueId(PLUID Luid);
VOID BuildExplicitAccessWithName(PEXPLICIT_ACCESS pExplicitAccess,LPTSTR pTrusteeName,DWORD AccessPermissions,ACCESS_MODE AccessMode,[AceFlags] Inheritance);
VOID BuildImpersonateExplicitAccessWithName(PEXPLICIT_ACCESS pExplicitAccess,LPTSTR pTrusteeName,PTRUSTEE pTrustee,DWORD AccessPermissions,ACCESS_MODE AccessMode,[AceFlags] Inheritance);
VOID BuildImpersonateTrustee(PTRUSTEE pTrustee,PTRUSTEE pImpersonateTrustee);
VOID BuildTrusteeWithName(PTRUSTEE pTrustee,LPTSTR pName);
void BuildTrusteeWithObjectsAndName(PTRUSTEE pTrustee,POBJECTS_AND_NAME pObjName,SE_OBJECT_TYPE ObjectType,LPTSTR ObjectTypeName,LPTSTR InheritedObjectTypeName,LPTSTR Name);
void BuildTrusteeWithObjectsAndSid(PTRUSTEE pTrustee,POBJECTS_AND_SID pObjSid,GUID* pObjectGuid,GUID* pInheritedObjectGuid,PSID pSid);
VOID BuildTrusteeWithSid(PTRUSTEE pTrustee,PSID pSid);
BOOL CheckTokenMembership(HANDLE TokenHandle,PSID SidToCheck,PBOOL IsMember);
BOOL ConvertSecurityDescriptorToStringSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,DWORD RequestedStringSDRevision,SECURITY_INFORMATION SecurityInformation,LPTSTR* StringSecurityDescriptor,PULONG StringSecurityDescriptorLen);
BOOL ConvertSidToStringSid(PSID Sid,LPTSTR* StringSid);
BOOL ConvertStringSecurityDescriptorToSecurityDescriptor(LPCTSTR StringSecurityDescriptor,DWORD StringSDRevision,PSECURITY_DESCRIPTOR* SecurityDescriptor,PULONG SecurityDescriptorSize);
BOOL ConvertStringSidToSid(LPCTSTR StringSid,PSID* Sid);
BOOL CopySid(DWORD nDestinationSidLength,PSID pDestinationSid,PSID pSourceSid);
BOOL CreateRestrictedToken(HANDLE ExistingTokenHandle,[CreateRestrictedTokenFlags] Flags,DWORD DisableSidCount,PSID_AND_ATTRIBUTES SidsToDisable,DWORD DeletePrivilegeCount,PLUID_AND_ATTRIBUTES PrivilegesToDelete,DWORD RestrictedSidCount,PSID_AND_ATTRIBUTES SidsToRestrict,PHANDLE NewTokenHandle);
BOOL CreateWellKnownSid(WELL_KNOWN_SID_TYPE WellKnownSidType,PSID DomainSid,PSID pSid,DWORD* cbSid);
BOOL DuplicateToken(HANDLE ExistingTokenHandle,SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,PHANDLE DuplicateTokenHandle);
BOOL DuplicateTokenEx(HANDLE hExistingToken,[TOKEN_ACCESS_MASK_DWORD] dwDesiredAccess,LPSECURITY_ATTRIBUTES lpTokenAttributes,SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,TOKEN_TYPE TokenType,PHANDLE phNewToken);
BOOL EqualDomainSid(PSID pSid1,PSID pSid2,BOOL* pfEqual);
BOOL EqualPrefixSid(PSID pSid1,PSID pSid2);
BOOL EqualSid(PSID pSid1,PSID pSid2);
PVOID FreeSid(PSID pSid);
[ERROR_CODE] GetAuditedPermissionsFromAcl(PACL pacl,PTRUSTEE pTrustee,PACCESS_MASK pSuccessfulAuditedRights,PACCESS_MASK pFailedAuditRights);
[ERROR_CODE] GetEffectiveRightsFromAcl(PACL pacl,PTRUSTEE pTrustee,PACCESS_MASK pAccessRights);
[ERROR_CODE] GetExplicitEntriesFromAcl(PACL pacl,PULONG pcCountOfExplicitEntries,PEXPLICIT_ACCESS* pListOfExplicitEntries);
DWORD GetLengthSid(PSID pSid);
PTRUSTEE GetMultipleTrustee(PTRUSTEE pTrustee);
MULTIPLE_TRUSTEE_OPERATION GetMultipleTrusteeOperation(PTRUSTEE pTrustee);
[ERROR_CODE] GetNamedSecurityInfo(LPTSTR pObjectName,SE_OBJECT_TYPE ObjectType,SECURITY_INFORMATION SecurityInfo,PSID* ppsidOwner,PSID* ppsidGroup,PACL* ppDacl,PACL* ppSacl,PSECURITY_DESCRIPTOR_RELATIVE* ppSecurityDescriptor);
BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR pSecurityDescriptor,PSECURITY_DESCRIPTOR_CONTROL pControl,LPDWORD lpdwRevision);
[ERROR_CODE] GetSecurityInfo(HANDLE handle,SE_OBJECT_TYPE ObjectType,SECURITY_INFORMATION SecurityInfo,PSID* ppsidOwner,PSID* ppsidGroup,PACL* ppDacl,PACL* ppSacl,PSECURITY_DESCRIPTOR* ppSecurityDescriptor);
PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID pSid);
DWORD GetSidLengthRequired(UCHAR nSubAuthorityCount);
PDWORD GetSidSubAuthority(PSID pSid,DWORD nSubAuthority);
PUCHAR GetSidSubAuthorityCount(PSID pSid);
BOOL GetTokenInformation(HANDLE TokenHandle,TOKEN_INFORMATION_CLASS TokenInformationClass,LPVOID TokenInformation,DWORD TokenInformationLength,PDWORD ReturnLength);
TRUSTEE_FORM GetTrusteeForm(PTRUSTEE pTrustee);
LPTSTR GetTrusteeName(PTRUSTEE pTrustee);
TRUSTEE_TYPE GetTrusteeType(PTRUSTEE pTrustee);
BOOL GetWindowsAccountDomainSid(PSID pSid,PSID ppDomainSid,DWORD* cbSid);
BOOL InitializeSid(PSID Sid,PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,BYTE nSubAuthorityCount);
BOOL IsTokenRestricted(HANDLE TokenHandle);
BOOL IsValidSid(PSID pSid);
BOOL IsWellKnownSid(PSID pSid,WELL_KNOWN_SID_TYPE WellKnownSidType);
BOOL LookupAccountName(LPCTSTR lpSystemName,LPCTSTR lpAccountName,PSID Sid,LPDWORD cbSid,LPTSTR ReferencedDomainName,LPDWORD cchReferencedDomainName,PSID_NAME_USE peUse);
BOOL LookupAccountSid(LPCTSTR lpSystemName,PSID lpSid,LPTSTR lpName,LPDWORD cchName,LPTSTR lpReferencedDomainName,LPDWORD cchReferencedDomainName,PSID_NAME_USE peUse);
BOOL LookupPrivilegeDisplayName(LPCTSTR lpSystemName,LPCTSTR lpName,LPTSTR lpDisplayName,LPDWORD cchDisplayName,LPDWORD lpLanguageId);
BOOL LookupPrivilegeName(LPCTSTR lpSystemName,PLUID lpLuid,LPTSTR lpName,LPDWORD cchName);
BOOL LookupPrivilegeValue(LPCTSTR lpSystemName,LPCTSTR lpName,PLUID lpLuid);
BOOL OpenProcessToken([ProcessHandle] ProcessHandle,[TOKEN_ACCESS_MASK_DWORD] DesiredAccess,PHANDLE TokenHandle);
BOOL OpenThreadToken([ThreadHandle] ThreadHandle,[TOKEN_ACCESS_MASK_DWORD] DesiredAccess,BOOL OpenAsSelf,PHANDLE TokenHandle);
VOID QuerySecurityAccessMask(SECURITY_INFORMATION SecurityInformation,LPDWORD DesiredAccess);
[ERROR_CODE] SetEntriesInAcl(ULONG cCountOfExplicitEntries,PEXPLICIT_ACCESS pListOfExplicitEntries,PACL OldAcl,PACL* NewAcl);
[ERROR_CODE] SetNamedSecurityInfo(LPTSTR pObjectName,SE_OBJECT_TYPE ObjectType,SECURITY_INFORMATION SecurityInfo,PSID psidOwner,PSID psidGroup,PACL pDacl,PACL pSacl);
VOID SetSecurityAccessMask(SECURITY_INFORMATION SecurityInformation,LPDWORD DesiredAccess);
BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR pSecurityDescriptor,SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet);
[ERROR_CODE] SetSecurityInfo(HANDLE handle,SE_OBJECT_TYPE ObjectType,SECURITY_INFORMATION SecurityInfo,PSID psidOwner,PSID psidGroup,PACL pDacl,PACL pSacl);
BOOL SetThreadToken(PHANDLE Thread,HANDLE Token);
BOOL SetTokenInformation(HANDLE TokenHandle,TOKEN_INFORMATION_CLASS TokenInformationClass,LPVOID TokenInformation,DWORD TokenInformationLength);
[ERROR_CODE] TreeResetNamedSecurityInfo(LPTSTR pObjectName,SE_OBJECT_TYPE ObjectType,SECURITY_INFORMATION SecurityInfo,PSID pOwner,PSID pGroup,PACL pDacl,PACL pSacl,BOOL KeepExplicit,FN_PROGRESS fnProgress,PROG_INVOKE_SETTING ProgressInvokeSetting,PVOID Args);
[ERROR_CODE] TreeSetNamedSecurityInfo(LPTSTR pObjectName,SE_OBJECT_TYPE ObjectType,SECURITY_INFORMATION SecurityInfo,PSID pOwner,PSID pGroup,PACL pDacl,PACL pSacl,[TreeSecAction] dwAction,FN_PROGRESS fnProgress,PROG_INVOKE_SETTING ProgressInvokeSetting,PVOID Args);
BOOL AreAllAccessesGranted(DWORD GrantedAccess,DWORD DesiredAccess);
BOOL AreAnyAccessesGranted(DWORD GrantedAccess,DWORD DesiredAccess);
[ERROR_CODE] BuildSecurityDescriptor(PTRUSTEE pOwner,PTRUSTEE pGroup,ULONG cCountOfAccessEntries,PEXPLICIT_ACCESS pListOfAccessEntries,ULONG cCountOfAuditEntries,PEXPLICIT_ACCESS pListOfAuditEntries,PSECURITY_DESCRIPTOR pOldSD,PULONG pSizeNewSD,PSECURITY_DESCRIPTOR* pNewSD);
BOOL ConvertToAutoInheritPrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor,PSECURITY_DESCRIPTOR CurrentSecurityDescriptor,PSECURITY_DESCRIPTOR* NewSecurityDescriptor,GUID* ObjectType,BOOLEAN IsDirectoryObject,PGENERIC_MAPPING GenericMapping);
BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR ParentDescriptor,PSECURITY_DESCRIPTOR CreatorDescriptor,PSECURITY_DESCRIPTOR* NewDescriptor,BOOL IsDirectoryObject,HANDLE Token,PGENERIC_MAPPING GenericMapping);
BOOL CreatePrivateObjectSecurityEx(PSECURITY_DESCRIPTOR ParentDescriptor,PSECURITY_DESCRIPTOR CreatorDescriptor,PSECURITY_DESCRIPTOR* NewDescriptor,GUID* ObjectType,BOOL IsContainerObject,[SEF_Flags] AutoInheritFlags,HANDLE Token,PGENERIC_MAPPING GenericMapping);
BOOL CreatePrivateObjectSecurityWithMultipleInheritance(PSECURITY_DESCRIPTOR ParentDescriptor,PSECURITY_DESCRIPTOR CreatorDescriptor,PSECURITY_DESCRIPTOR* NewDescriptor,GUID** ObjectTypes,ULONG GuidCount,BOOL IsContainerObject,[SEF_Flags] AutoInheritFlags,HANDLE Token,PGENERIC_MAPPING GenericMapping);
BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR* ObjectDescriptor);
BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR ObjectDescriptor,SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR ResultantDescriptor,DWORD DescriptorLength,PDWORD ReturnLength);
BOOL ImpersonateAnonymousToken([ThreadHandle] ThreadHandle);
BOOL ImpersonateLoggedOnUser(HANDLE hToken);
BOOL ImpersonateNamedPipeClient(HANDLE hNamedPipe);
BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
[ERROR_CODE] LookupSecurityDescriptorParts(PTRUSTEE* pOwner,PTRUSTEE* pGroup,PULONG cCountOfAccessEntries,PEXPLICIT_ACCESS* pListOfAccessEntries,PULONG cCountOfAuditEntries,PEXPLICIT_ACCESS* pListOfAuditEntries,PSECURITY_DESCRIPTOR pSD);
VOID MapGenericMask(PDWORD AccessMask,PGENERIC_MAPPING GenericMapping);
BOOL ObjectCloseAuditAlarm(LPCTSTR SubsystemName,LPVOID HandleId,BOOL GenerateOnClose);
BOOL ObjectDeleteAuditAlarm(LPCTSTR SubsystemName,LPVOID HandleId,BOOL GenerateOnClose);
BOOL ObjectOpenAuditAlarm(LPCTSTR SubsystemName,LPVOID HandleId,LPTSTR ObjectTypeName,LPTSTR ObjectName,PSECURITY_DESCRIPTOR pSecurityDescriptor,HANDLE ClientToken,DWORD DesiredAccess,DWORD GrantedAccess,PPRIVILEGE_SET Privileges,BOOL ObjectCreation,BOOL AccessGranted,LPBOOL GenerateOnClose);
BOOL ObjectPrivilegeAuditAlarm(LPCTSTR SubsystemName,LPVOID HandleId,HANDLE ClientToken,DWORD DesiredAccess,PPRIVILEGE_SET Privileges,BOOL AccessGranted);
BOOL PrivilegeCheck(HANDLE ClientToken,PPRIVILEGE_SET RequiredPrivileges,LPBOOL pfResult);
BOOL PrivilegedServiceAuditAlarm(LPCTSTR SubsystemName,LPCTSTR ServiceName,HANDLE ClientToken,PPRIVILEGE_SET Privileges,BOOL AccessGranted);
BOOL RevertToSelf();
BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR ModificationDescriptor,PSECURITY_DESCRIPTOR* ObjectsSecurityDescriptor,PGENERIC_MAPPING GenericMapping,HANDLE Token);
BOOL SetPrivateObjectSecurityEx(SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR ModificationDescriptor,PSECURITY_DESCRIPTOR* ObjectsSecurityDescriptor,[SEF_Flags] AutoInheritFlags,PGENERIC_MAPPING GenericMapping,HANDLE Token);
[ERROR_CODE] GetSecurityDescriptorRMControl(PSECURITY_DESCRIPTOR SecurityDescriptor,PUCHAR RMControl);
[ERROR_CODE] SetSecurityDescriptorRMControl(PSECURITY_DESCRIPTOR SecurityDescriptor,PUCHAR RMControl);
BOOL AccessCheckAndAuditAlarm(LPCTSTR SubsystemName,LPVOID HandleId,LPTSTR ObjectTypeName,LPTSTR ObjectName,PSECURITY_DESCRIPTOR SecurityDescriptor,DWORD DesiredAccess,PGENERIC_MAPPING GenericMapping,BOOL ObjectCreation,LPDWORD GrantedAccess,LPBOOL AccessStatus,LPBOOL pfGenerateOnClose);
BOOL AccessCheckByTypeAndAuditAlarm(LPCTSTR SubsystemName,LPVOID HandleId,LPCTSTR ObjectTypeName,LPCTSTR ObjectName,PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID PrincipalSelfSid,DWORD DesiredAccess,AUDIT_EVENT_TYPE AuditType,DWORD Flags,POBJECT_TYPE_LIST ObjectTypeList,DWORD ObjectTypeListLength,PGENERIC_MAPPING GenericMapping,BOOL ObjectCreation,LPDWORD GrantedAccess,LPBOOL AccessStatus,LPBOOL pfGenerateOnClose);
BOOL AccessCheckByTypeResultListAndAuditAlarm(LPCTSTR SubsystemName,LPVOID HandleId,LPCTSTR ObjectTypeName,LPCTSTR ObjectName,PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID PrincipalSelfSid,DWORD DesiredAccess,AUDIT_EVENT_TYPE AuditType,DWORD Flags,POBJECT_TYPE_LIST ObjectTypeList,DWORD ObjectTypeListLength,PGENERIC_MAPPING GenericMapping,BOOL ObjectCreation,LPDWORD GrantedAccess,LPDWORD AccessStatusList,LPBOOL pfGenerateOnClose);
BOOL AccessCheckByTypeResultListAndAuditAlarmByHandle(LPCTSTR SubsystemName,LPVOID HandleId,HANDLE ClientToken,LPCTSTR ObjectTypeName,LPCTSTR ObjectName,PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID PrincipalSelfSid,DWORD DesiredAccess,AUDIT_EVENT_TYPE AuditType,DWORD Flags,POBJECT_TYPE_LIST ObjectTypeList,DWORD ObjectTypeListLength,PGENERIC_MAPPING GenericMapping,BOOL ObjectCreation,LPDWORD GrantedAccess,LPDWORD AccessStatusList,LPBOOL pfGenerateOnClose);
BOOL AddAccessAllowedAce(PACL pAcl,DWORD dwAceRevision,[ACCESS_MASK_DWORD] AccessMask,PSID pSid);
BOOL AddAccessAllowedAceEx(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[ACCESS_MASK_DWORD] AccessMask,PSID pSid);
BOOL AddAccessAllowedObjectAce(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[ACCESS_MASK_DWORD] AccessMask,GUID* ObjectTypeGuid,GUID* InheritedObjectTypeGuid,PSID pSid);
BOOL AddAccessDeniedAce(PACL pAcl,DWORD dwAceRevision,[ACCESS_MASK_DWORD] AccessMask,PSID pSid);
BOOL AddAccessDeniedAceEx(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[ACCESS_MASK_DWORD] AccessMask,PSID pSid);
BOOL AddAccessDeniedObjectAce(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[ACCESS_MASK_DWORD] AccessMask,GUID* ObjectTypeGuid,GUID* InheritedObjectTypeGuid,PSID pSid);
BOOL AddAce(PACL pAcl,DWORD dwAceRevision,DWORD dwStartingAceIndex,LPVOID pAceList,DWORD nAceListLength);
BOOL AddAuditAccessAce(PACL pAcl,DWORD dwAceRevision,[ACCESS_MASK_DWORD] dwAccessMask,PSID pSid,BOOL bAuditSuccess,BOOL bAuditFailure);
BOOL AddAuditAccessAceEx(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[ACCESS_MASK_DWORD] dwAccessMask,PSID pSid,BOOL bAuditSuccess,BOOL bAuditFailure);
BOOL AddAuditAccessObjectAce(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[ACCESS_MASK_DWORD] AccessMask,GUID* ObjectTypeGuid,GUID* InheritedObjectTypeGuid,PSID pSid,BOOL bAuditSuccess,BOOL bAuditFailure);
BOOL AddMandatoryAce(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[MandatoryPolicyFlags] MandatoryPolicy,PSID pLabelSid);
BOOL DeleteAce(PACL pAcl,DWORD dwAceIndex);
BOOL FindFirstFreeAce(PACL pAcl,PACE* pAce);
[ERROR_CODE] FreeInheritedFromArray(PINHERITED_FROM pInheritArray,USHORT AceCnt,PFN_OBJECT_MGR_FUNCTS pfnArray);
BOOL GetAce(PACL pAcl,DWORD dwAceIndex,PACE* pAce);
BOOL GetAclInformation(PACL pAcl,LPVOID pAclInformation,DWORD nAclInformationLength,ACL_INFORMATION_CLASS dwAclInformationClass);
BOOL GetFileSecurity(LPCTSTR lpFileName,SECURITY_INFORMATION RequestedInformation,PSECURITY_DESCRIPTOR pSecurityDescriptor,DWORD nLength,LPDWORD lpnLengthNeeded);
[ERROR_CODE] GetInheritanceSource(LPTSTR pObjectName,SE_OBJECT_TYPE ObjectType,SECURITY_INFORMATION SecurityInfo,BOOL Container,GUID** pObjectClassGuids,DWORD GuidCount,PACL pAcl,PFN_OBJECT_MGR_FUNCTS pfnArray,PGENERIC_MAPPING pGenericMapping,PINHERITED_FROM pInheritArray);
BOOL GetKernelObjectSecurity(HANDLE Handle,SECURITY_INFORMATION RequestedInformation,PISECURITY_DESCRIPTOR_RELATIVE pSecurityDescriptor,DWORD nLength,LPDWORD lpnLengthNeeded);
BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,LPBOOL lpbDaclPresent,PACL* pDacl,LPBOOL lpbDaclDefaulted);
BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID* pGroup,LPBOOL lpbGroupDefaulted);
DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR pSecurityDescriptor);
BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID* pOwner,LPBOOL lpbOwnerDefaulted);
BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,LPBOOL lpbSaclPresent,PACL* pSacl,LPBOOL lpbSaclDefaulted);
BOOL InitializeAcl(PACL pAcl,DWORD nAclLength,DWORD dwAclRevision);
BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor,DWORD dwRevision);
BOOL IsValidAcl(PACL pAcl);
BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor);
BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR_RELATIVE pSelfRelativeSD,PSECURITY_DESCRIPTOR pAbsoluteSD,LPDWORD lpdwAbsoluteSDSize,PACL pDacl,LPDWORD lpdwDaclSize,PACL pSacl,LPDWORD lpdwSaclSize,PSID pOwner,LPDWORD lpdwOwnerSize,PSID pPrimaryGroup,LPDWORD lpdwPrimaryGroupSize);
BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR pAbsoluteSD,PSECURITY_DESCRIPTOR pSelfRelativeSD,LPDWORD lpdwBufferLength);
BOOL QueryServiceObjectSecurity(SC_HANDLE hService,SECURITY_INFORMATION dwSecurityInformation,PSECURITY_DESCRIPTOR lpSecurityDescriptor,DWORD cbBufSize,LPDWORD pcbBytesNeeded);
[REG_ERROR] RegGetKeySecurity(HKEY hKey,SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR pSecurityDescriptor,LPDWORD lpcbSecurityDescriptor);
[REG_ERROR] RegSetKeySecurity(HKEY hKey,SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR pSecurityDescriptor);
BOOL SetAclInformation(PACL pAcl,LPVOID pAclInformation,DWORD nAclInformationLength,ACL_INFORMATION_CLASS dwAclInformationClass);
BOOL SetFileSecurity(LPCTSTR lpFileName,SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR pSecurityDescriptor);
BOOL SetKernelObjectSecurity(HANDLE Handle,SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR SecurityDescriptor);
BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,BOOL bDaclPresent,PACL pDacl,BOOL bDaclDefaulted);
BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID pGroup,BOOL bGroupDefaulted);
BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor,PSID pOwner,BOOL bOwnerDefaulted);
BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,BOOL bSaclPresent,PACL pSacl,BOOL bSaclDefaulted);
BOOL SetServiceObjectSecurity(SC_HANDLE hService,SECURITY_INFORMATION dwSecurityInformation,PSECURITY_DESCRIPTOR lpSecurityDescriptor);
BOOLEAN AuditComputeEffectivePolicyBySid(const PSID pSid,const GUID* pSubCategoryGuids,ULONG PolicyCount,PAUDIT_POLICY_INFORMATION* ppAuditPolicy);
BOOLEAN AuditComputeEffectivePolicyByToken(HANDLE hTokenHandle,const GUID* pSubCategoryGuids,ULONG PolicyCount,PAUDIT_POLICY_INFORMATION* ppAuditPolicy);
BOOLEAN AuditEnumerateCategories(GUID** ppAuditCategoriesArray,PULONG pCountReturned);
BOOLEAN AuditEnumeratePerUserPolicy(PPOLICY_AUDIT_SID_ARRAY* ppAuditSidArray);
BOOLEAN AuditEnumerateSubCategories(const GUID* pAuditCategoryGuid,BOOLEAN bRetrieveAllSubCategories,GUID** ppAuditSubCategoriesArray,PULONG pCountReturned);
VOID AuditFree(PVOID Buffer);
BOOLEAN AuditLookupCategoryGuidFromCategoryId(POLICY_AUDIT_EVENT_TYPE AuditCategoryId,GUID* pAuditCategoryGuid);
BOOLEAN AuditLookupCategoryIdFromCategoryGuid(const GUID* pAuditCategoryGuid,PPOLICY_AUDIT_EVENT_TYPE pAuditCategoryId);
BOOLEAN AuditLookupCategoryName(const GUID* pAuditCategoryGuid,PTSTR* ppszCategoryName);
BOOLEAN AuditLookupSubCategoryName(const GUID* pAuditSubCategoryGuid,PTSTR* ppszSubCategoryName);
BOOLEAN AuditQueryPerUserPolicy(const PSID pSid,const GUID* pSubCategoryGuids,ULONG PolicyCount,PAUDIT_POLICY_INFORMATION* ppAuditPolicy);
BOOLEAN AuditQuerySystemPolicy(const GUID* pSubCategoryGuids,ULONG PolicyCount,PAUDIT_POLICY_INFORMATION* ppAuditPolicy);
BOOLEAN AuditSetPerUserPolicy(const PSID pSid,PCAUDIT_POLICY_INFORMATION pAuditPolicy,ULONG PolicyCount);
BOOLEAN AuditSetSystemPolicy(PCAUDIT_POLICY_INFORMATION pAuditPolicy,ULONG PolicyCount);
BOOLEAN AuditQueryGlobalSacl(PCTSTR ObjectTypeName,PACL* Acl);
BOOLEAN AuditSetGlobalSacl(PCTSTR ObjectTypeName,PACL Acl);
BOOLEAN AuditQuerySecurity(SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR* ppSecurityDescriptor);
BOOLEAN AuditSetSecurity(SECURITY_INFORMATION SecurityInformation,PSECURITY_DESCRIPTOR pSecurityDescriptor);
BOOL AddConditionalAce(PACL pAcl,DWORD dwAceRevision,[AceFlags] AceFlags,[ACE_TYPE|UCHAR] AceType,[ACCESS_MASK_DWORD] AccessMask,PSID pSid,PWCHAR ConditionStr,DWORD* ReturnLength);
BOOL GetAppContainerNamedObjectPath(HANDLE Token,PSID AppContainerSid,ULONG ObjectPathLength,LPWSTR ObjectPath,PULONG ReturnLength);
BOOL LogonUser(LPTSTR lpszUsername,LPTSTR lpszDomain,LPTSTR lpszPassword,[LogonType] dwLogonType,[LogonProvider] dwLogonProvider,PHANDLE phToken);
BOOL LogonUserEx(LPTSTR lpszUsername,LPTSTR lpszDomain,LPTSTR lpszPassword,[LogonType] dwLogonType,[LogonProvider] dwLogonProvider,PHANDLE phToken,PSID* ppLogonSid,PVOID* ppProfileBuffer,LPDWORD pdwProfileLength,PQUOTA_LIMITS pQuotaLimits);
BOOL LogonUserExExW(LPWSTR lpszUsername,LPWSTR lpszDomain,LPWSTR lpszPassword,[LogonType] dwLogonType,PTOKEN_GROUPS pTokenGroups,[LogonProvider] dwLogonProvider,PHANDLE phToken,PSID* ppLogonSid,PVOID* ppProfileBuffer,LPDWORD pdwProfileLength,PQUOTA_LIMITS pQuotaLimits);
BOOL CredDelete(LPCTSTR TargetName,DWORD Type,DWORD Flags);
BOOL CredEnumerate(LPCTSTR Filter,[CredEnumerateFlags] Flags,DWORD* Count,PCREDENTIAL** Credentials);
BOOL CredFindBestCredential(LPCTSTR TargetName,DWORD Type,DWORD Flags,PCREDENTIAL* Credential);
VOID CredFree(PVOID Buffer);
BOOL CredGetSessionTypes(DWORD MaximumPersistCount,LPDWORD MaximumPersist);
BOOL CredGetTargetInfo(LPCTSTR TargetName,[CredGetTargetInfoFlags] Flags,PCREDENTIAL_TARGET_INFORMATION* TargetInfo);
BOOL CredIsProtected(LPTSTR pszProtectedCredentials,CRED_PROTECTION_TYPE* pProtectionType);
BOOL CredProtect(BOOL fAsSelf,LPTSTR pszCredentials,DWORD cchCredentials,LPTSTR pszProtectedCredentials,DWORD* pcchMaxChars,CRED_PROTECTION_TYPE* ProtectionType);
BOOL CredMarshalCredential(CRED_MARSHAL_TYPE CredType,PVOID Credential,LPTSTR* MarshaledCredential);
BOOL CredRead(LPCTSTR TargetName,[CredType] Type,DWORD Flags,PCREDENTIAL* Credential);
BOOL CredReadDomainCredentials(PCREDENTIAL_TARGET_INFORMATION TargetInfo,DWORD Flags,DWORD* Count,PCREDENTIAL** Credentials);
BOOL CredRename(LPCTSTR OldTargetName,LPCTSTR NewTargetName,DWORD Type,DWORD Flags);
BOOL CredUnmarshalCredential(LPCTSTR MarshaledCredential,PCRED_MARSHAL_TYPE CredType,PVOID* Credential);
BOOL CredUnprotect(BOOL fAsSelf,LPTSTR pszProtectedCredentials,DWORD cchCredentials,LPTSTR pszCredentials,DWORD* pcchMaxChars);
BOOL CredWrite(PCREDENTIAL Credential,DWORD Flags);
BOOL CredWriteDomainCredentials(PCREDENTIAL_TARGET_INFORMATION TargetInfo,PCREDENTIAL Credential,DWORD Flags);
BOOL CredIsMarshaledCredential(LPTSTR MarshaledCredential);
NTSTATUS LsaEnumerateAccountsWithUserRight(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING UserRights,PVOID* EnumerationBuffer,PULONG CountReturned);
NTSTATUS LsaEnumerateTrustedDomainsEx(LSA_HANDLE PolicyHandle,PLSA_ENUMERATION_HANDLE EnumerationContext,PVOID* Buffer,ULONG PreferredMaximumLength,PULONG CountReturned);
NTSTATUS LsaLookupNames(LSA_HANDLE PolicyHandle,ULONG Count,PLSA_UNICODE_STRING Names,PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,PLSA_TRANSLATED_SID* Sids);
NTSTATUS LsaLookupNames2(LSA_HANDLE PolicyHandle,[LSA_LOOKUP_FLAGS] Flags,ULONG Count,PLSA_UNICODE_STRING Names,PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,PLSA_TRANSLATED_SID2* Sids);
NTSTATUS LsaLookupPrivilegeValue(LSA_HANDLE PolicyHandle,PUNICODE_STRING Name,PLUID Value);
NTSTATUS LsaLookupSids(LSA_HANDLE PolicyHandle,ULONG Count,PSID* Sids,PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,PLSA_TRANSLATED_NAME* Names);
NTSTATUS LsaLookupSids2(LSA_HANDLE PolicyHandle,ULONG LookupOptions,ULONG Count,PSID* Sids,PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,PLSA_TRANSLATED_NAME* Names);
NTSTATUS LsaAddAccountRights(LSA_HANDLE PolicyHandle,PSID AccountSid,PLSA_UNICODE_STRING UserRights,ULONG CountOfRights);
NTSTATUS LsaEnumerateAccountRights(LSA_HANDLE PolicyHandle,PSID AccountSid,PLSA_UNICODE_STRING* UserRights,PULONG CountOfRights);
NTSTATUS LsaRemoveAccountRights(LSA_HANDLE PolicyHandle,PSID AccountSid,BOOLEAN AllRights,PLSA_UNICODE_STRING UserRights,ULONG CountOfRights);
NTSTATUS LsaCreateTrustedDomainEx(LSA_HANDLE PolicyHandle,PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,ACCESS_MASK DesiredAccess,PLSA_HANDLE TrustedDomainHandle);
NTSTATUS LsaDeleteTrustedDomain(LSA_HANDLE PolicyHandle,PSID TrustedDomainSid);
NTSTATUS LsaEnumerateTrustedDomains(LSA_HANDLE PolicyHandle,PLSA_ENUMERATION_HANDLE EnumerationContext,PVOID* Buffer,ULONG PreferedMaximumLength,PULONG CountReturned);
NTSTATUS LsaOpenTrustedDomainByName(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING TrustedDomainName,ACCESS_MASK DesiredAccess,PLSA_HANDLE TrustedDomainHandle);
NTSTATUS LsaQueryTrustedDomainInfo(LSA_HANDLE PolicyHandle,PSID TrustedDomainSid,TRUSTED_INFORMATION_CLASS InformationClass,PVOID* Buffer);
NTSTATUS LsaQueryTrustedDomainInfoByName(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING TrustedDomainName,TRUSTED_INFORMATION_CLASS InformationClass,PVOID* Buffer);
NTSTATUS LsaSetTrustedDomainInfoByName(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING TrustedDomainName,TRUSTED_INFORMATION_CLASS InformationClass,PVOID Buffer);
NTSTATUS LsaSetTrustedDomainInformation(LSA_HANDLE PolicyHandle,PSID TrustedDomainSid,TRUSTED_INFORMATION_CLASS InformationClass,PVOID Buffer);
NTSTATUS LsaRetrievePrivateData(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING KeyName,PLSA_UNICODE_STRING* PrivateData);
NTSTATUS LsaStorePrivateData(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING KeyName,PLSA_UNICODE_STRING PrivateData);
NTSTATUS LsaClose(LSA_HANDLE ObjectHandle);
NTSTATUS LsaFreeMemory(PVOID Buffer);
[ERROR_CODE_ULONG] LsaNtStatusToWinError(NTSTATUS Status);
BOOL SaferCloseLevel(SAFER_LEVEL_HANDLE hLevelHandle);
BOOL SaferIdentifyLevel(DWORD dwNumProperties,PSAFER_CODE_PROPERTIES pCodeProperties,SAFER_LEVEL_HANDLE* pLevelHandle,LPVOID lpReserved);
BOOL SaferComputeTokenFromLevel(SAFER_LEVEL_HANDLE LevelHandle,HANDLE InAccessToken,PHANDLE OutAccessToken,DWORD dwFlags,LPVOID lpReserved);
BOOL SaferCreateLevel([SaferScopeId] dwScopeId,DWORD dwLevelId,DWORD OpenFlags,SAFER_LEVEL_HANDLE* pLevelHandle,LPVOID lpReserved);
BOOL SaferGetLevelInformation(SAFER_LEVEL_HANDLE LevelHandle,SAFER_OBJECT_INFO_CLASS dwInfoType,LPVOID lpQueryBuffer,DWORD dwInBufferSize,LPDWORD lpdwOutBufferSize);
BOOL SaferGetPolicyInformation([SaferScopeId] dwScopeId,SAFER_POLICY_INFO_CLASS SaferPolicyInfoClass,DWORD InfoBufferSize,PVOID InfoBuffer,PDWORD InfoBufferRetSize,LPVOID lpReserved);
BOOL SaferiIsExecutableFileType(LPCWSTR szFullPath,BOOLEAN bFromShellExecute);
BOOL SaferRecordEventLogEntry(SAFER_LEVEL_HANDLE hLevel,LPCWSTR szTargetPath,LPVOID lpReserved);
VOID CloseThreadWaitChainSession(HWCT WctHandle);
BOOL GetThreadWaitChain(HWCT WctHandle,DWORD_PTR Context,DWORD Flags,DWORD ThreadId,LPDWORD NodeCount,PWAITCHAIN_NODE_INFO NodeInfoArray,LPBOOL IsCycle);
HWCT OpenThreadWaitChainSession(DWORD Flags,PWAITCHAINCALLBACK callback);
VOID RegisterWaitChainCOMCallback(PCOGETCALLSTATE CallStateCallback,PCOGETACTIVATIONSTATE ActivationStateCallback);
NTSTATUS LsaOpenPolicy(PLSA_UNICODE_STRING SystemName,PLSA_OBJECT_ATTRIBUTES ObjectAttributes,ACCESS_MASK DesiredAccess,PLSA_HANDLE PolicyHandle);
NTSTATUS LsaQueryInformationPolicy(LSA_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PVOID* Buffer);
NTSTATUS LsaSetInformationPolicy(LSA_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PVOID Buffer);
NTSTATUS LsaGetAppliedCAPIDs(PLSA_UNICODE_STRING SystemName,PSID** CAPIDs,PULONG CAPIDCount);
NTSTATUS LsaQueryCAPs(PSID* CAPIDs,ULONG CAPIDCount,PCENTRAL_ACCESS_POLICY* CAPs,PULONG CAPCount);
NTSTATUS LsaSetCAPs(PLSA_UNICODE_STRING CAPDNs,ULONG CAPDNCount,ULONG Flags);
NTSTATUS LsaQueryDomainInformationPolicy(LSA_HANDLE PolicyHandle,POLICY_DOMAIN_INFORMATION_CLASS InformationClass,PVOID* Buffer);
NTSTATUS LsaQueryForestTrustInformation(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING TrustedDomainName,PLSA_FOREST_TRUST_INFORMATION* ForestTrustInfo);
NTSTATUS LsaSetDomainInformationPolicy(LSA_HANDLE PolicyHandle,POLICY_DOMAIN_INFORMATION_CLASS InformationClass,PVOID Buffer);
NTSTATUS LsaSetForestTrustInformation(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING TrustedDomainName,PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,BOOLEAN CheckOnly,PLSA_FOREST_TRUST_COLLISION_INFORMATION* CollisionInfo);
NTSTATUS LsaOpenSecret(LSA_HANDLE PolicyHandle,PLSA_UNICODE_STRING SecretName,ACCESS_MASK DesiredAccess,PLSA_HANDLE SecretHandle);
NTSTATUS LsaSetSecret(LSA_HANDLE SecretHandle,PLSA_UNICODE_STRING CurrentValue,PLSA_UNICODE_STRING OldValue);
NTSTATUS LsaQuerySecret(LSA_HANDLE SecretHandle,PLSA_UNICODE_STRING* CurrentValue,PLARGE_INTEGER CurrentValueSetTime,PLSA_UNICODE_STRING* OldValue,PLARGE_INTEGER OldValueSetTime);
BOOLEAN SystemFunction036(PVOID RandomBuffer,ULONG RandomBufferLength);
NTSTATUS SystemFunction040(PVOID Memory,ULONG MemorySize,[RTL_ENCRYPT_OPTION_FLAGS] OptionFlags);
NTSTATUS SystemFunction041(PVOID Memory,ULONG MemorySize,[RTL_ENCRYPT_OPTION_FLAGS] OptionFlags);