551 lines
27 KiB
C++
551 lines
27 KiB
C++
#pragma once
|
|
#include <windows.h>
|
|
#include <wchar.h>
|
|
#include <string>
|
|
|
|
#define ALL_SHARING FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE
|
|
#define GENERIC_READ_WRITE GENERIC_READ|GENERIC_WRITE
|
|
#define InitializeObjectAttributes( p, n, a, r, s ) { \
|
|
(p)->uLength = sizeof( OBJECT_ATTRIBUTES ); \
|
|
(p)->hRootDirectory = r; \
|
|
(p)->uAttributes = a; \
|
|
(p)->pObjectName = n; \
|
|
(p)->pSecurityDescriptor = s; \
|
|
(p)->pSecurityQualityOfService = NULL; \
|
|
}
|
|
#define lock_ptr OpsMaster::FileOpLock*
|
|
#define USE_USER_TEMP_DIR 0x190
|
|
#define USE_SYSTEM_TEMP_DIR 0x1F4
|
|
#define USE_CUSTOM_TEMP_DIR 0x258
|
|
|
|
typedef void(*_UserCallback)();
|
|
class OpsMaster {
|
|
|
|
public:
|
|
/// the constructor will be used to import native functions to make them ready to call
|
|
OpsMaster();
|
|
/// <summary>
|
|
/// Get last error from a call using OpsMaster class
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
DWORD GetLastErr();
|
|
/// <summary>
|
|
/// convert NTSTATUS error code to DOS error code
|
|
/// </summary>
|
|
/// <param name="status">NTSTATUS error code to be converted</param>
|
|
/// <returns></returns>
|
|
DWORD NtStatusToDOS(NTSTATUS status);
|
|
|
|
/// <summary>
|
|
/// Move a file or directory using an existing handle with DELETE access
|
|
/// </summary>
|
|
/// <param name="hfile">A valid handle with delete access to a file or directory</param>
|
|
/// <param name="target">A valid path to a directory which should not exceed MAX_PATH</param>
|
|
/// <returns>if the function suceed it will return true, if not call OpsMaster::GetLastError to retrieve the error code</returns>
|
|
bool MoveByHandle(HANDLE hfile, std::wstring target);
|
|
/// <summary>
|
|
/// Move a file or directory using an existing handle with DELETE access
|
|
/// </summary>
|
|
/// <param name="hfile">A valid handle with delete access to a file or directory</param>
|
|
/// <param name="target">A valid path to a directory which should not exceed MAX_PATH</param>
|
|
/// <returns>if the function suceed it will return true, if not call OpsMaster::GetLastError to retrieve the error code</returns>
|
|
bool MoveByHandle(HANDLE hfile, std::string target);
|
|
/// <summary>
|
|
/// Retrive a HANDLE to directory
|
|
/// </summary>
|
|
/// <param name="directory">The name of the directory to be opened</param>
|
|
/// <param name="access_mask">The desired access of the file to be opened, default is GENERIC_READ|GENERIC_WRITE</param>
|
|
/// <param name="share_mode">The share mode, default is FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE</param>
|
|
/// <param name="creation_disposition">The creation disposition this value can be CREATE_NEW or OPEN_EXISTING or OPEN_ALWAYS</param>
|
|
/// <returns>if the function succeed the return value is a valid HANDLE to the target directory, call GetLastErr for extended info about the error</returns>
|
|
HANDLE OpenDirectory(std::wstring directory,
|
|
DWORD access_mask = MAXIMUM_ALLOWED,
|
|
DWORD share_mode = ALL_SHARING, DWORD creation_disposition = OPEN_ALWAYS, DWORD flags = 0);
|
|
/// <summary>
|
|
/// Retrive a HANDLE to directory
|
|
/// </summary>
|
|
/// <param name="directory">The name of the directory to be opened</param>
|
|
/// <param name="access_mask">The desired access of the file to be opened, default is GENERIC_READ|GENERIC_WRITE</param>
|
|
/// <param name="share_mode">The share mode, default is FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE</param>
|
|
/// <param name="creation_disposition">The creation disposition this value can be CREATE_NEW or OPEN_EXISTING or OPEN_ALWAYS</param>
|
|
/// <returns>if the function succeed the return value is a valid HANDLE to the target directory, call GetLastErr for extended info about the error</returns>
|
|
HANDLE OpenDirectory(std::string directory,
|
|
DWORD access_mask = MAXIMUM_ALLOWED,
|
|
DWORD share_mode = ALL_SHARING, DWORD creation_disposition = OPEN_ALWAYS, DWORD flags = 0);
|
|
/// <summary>
|
|
/// Retrive a HANDLE to directory
|
|
/// </summary>
|
|
/// <param name="directory">The name of the directory to be opened</param>
|
|
/// <param name="access_mask">The desired access of the file to be opened, default is GENERIC_READ|GENERIC_WRITE</param>
|
|
/// <param name="share_mode">The share mode, default is FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE</param>
|
|
/// <param name="creation_disposition">For more info about this please visite https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew</param>
|
|
/// <returns>if the function succeed the return value is a valid HANDLE to the target file, call GetLastErr for extended info about the error</returns>
|
|
HANDLE OpenFileNative(std::wstring file,
|
|
DWORD access_mask = MAXIMUM_ALLOWED,
|
|
DWORD share_mode = ALL_SHARING, DWORD creation_dispostion = OPEN_ALWAYS, DWORD flags = 0);
|
|
/// <summary>
|
|
/// Retrive a HANDLE to directory
|
|
/// </summary>
|
|
/// <param name="directory">The name of the directory to be opened</param>
|
|
/// <param name="access_mask">The desired access of the file to be opened, default is GENERIC_READ|GENERIC_WRITE</param>
|
|
/// <param name="share_mode">The share mode, default is FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE</param>
|
|
/// <param name="creation_disposition">For more info about this please visite https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew</param>
|
|
/// <returns>if the function succeed the return value is a valid HANDLE to the target file, call GetLastErr for extended info about the error</returns>
|
|
HANDLE OpenFileNative(std::string file,
|
|
DWORD access_mask = MAXIMUM_ALLOWED,
|
|
DWORD share_mode = ALL_SHARING, DWORD creation_dispostion = OPEN_ALWAYS, DWORD flags = 0);
|
|
/// <summary>
|
|
/// terminate a process by pid
|
|
/// </summary>
|
|
/// <param name="process_id">the pid of the process to be terminated</param>
|
|
/// <returns>return true if the function succeed, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
|
|
/// <summary>
|
|
/// Call NtWriteFile to write data to file
|
|
/// </summary>
|
|
/// <param name="hfile">HANDLE to a file with GENERIC_WRITE access</param>
|
|
/// <param name="lpBuffer">The buffer to write to the file</param>
|
|
/// <param name="nNumberOfBytesToWrite">Number of bytes to write, this parameter cannot be null</param>
|
|
/// <param name="lpNumberOfBytesWritten">An optional pointer to a DWORD that receive the number of bytes written</param>
|
|
/// <returns>Return true if succeed</returns>
|
|
bool WriteFileNative(HANDLE hfile, PVOID lpBuffer, DWORD nNumberOfBytesToWrite,
|
|
LPDWORD lpNumberOfBytesWritten = NULL);
|
|
/// <summary>
|
|
/// Call NtReadFile to read data from a file
|
|
/// </summary>
|
|
/// <param name="hFile">HANDLE to a file with GENERIC_READ access</param>
|
|
/// <param name="lpBuffer">[OUT] The buffer that receive the data of the file</param>
|
|
/// <param name="nNumberOfBytesToRead">Number of bytes to read, if not specified the entire file is going to be read</param>
|
|
/// <param name="lpNumberOfBytesRead">An optional pointer to a DWORD that receive the number of bytes written</param>
|
|
/// <returns></returns>
|
|
bool ReadFileNative(HANDLE hFile, LPVOID lpBuffer,
|
|
DWORD nNumberOfBytesToRead = NULL,
|
|
LPDWORD lpNumberOfBytesRead = NULL);
|
|
/// <summary>
|
|
/// Call this function to cause a BSOD
|
|
/// SeShutdownPrivilege is required to call this function
|
|
/// if the function return it means that the function failed
|
|
/// this function is mainly used to generate kernel crash dump file in c:\windows\memory.dmp
|
|
/// </summary>
|
|
void bsod();
|
|
/// <summary>
|
|
/// Open named pipe using native NtCreateFile function
|
|
/// </summary>
|
|
/// <param name="pipe_name">The name of the pipe to be opened</param>
|
|
/// <param name="desired_access">Desired access to the pipe to be opened the default is GENERIC_READ</param>
|
|
/// <param name="impersonation_level">Impersonation level, the default is SECURITY_IMPERSONATION for more please visite https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew </param>
|
|
/// <returns>return a valid HANDLE if the function succeed, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
HANDLE OpenNamedPipe(std::wstring pipe_name, DWORD desired_access = GENERIC_READ,
|
|
DWORD impersonation_level = SECURITY_IMPERSONATION);
|
|
/// <summary>
|
|
/// Open named pipe using native NtCreateFile function
|
|
/// </summary>
|
|
/// <param name="pipe_name">The name of the pipe to be opened</param>
|
|
/// <param name="desired_access">Desired access to the pipe to be opened the default is GENERIC_READ</param>
|
|
/// <param name="impersonation_level">Impersonation level, the default is SECURITY_IMPERSONATION for more please visite https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew </param>
|
|
/// <returns>return a valid HANDLE if the function succeed, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
HANDLE OpenNamedPipe(std::string pipe_name, DWORD desired_access = GENERIC_READ,
|
|
DWORD impersonation_level = SECURITY_IMPERSONATION);
|
|
/// <summary>
|
|
/// Create native hardlink to file
|
|
/// </summary>
|
|
/// <param name="link">the path to the link to be created</param>
|
|
/// <param name="target">the path to the target file</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
bool CreateNativeHardLink(std::wstring link, std::wstring target);
|
|
/// <summary>
|
|
/// Create native hardlink to file
|
|
/// </summary>
|
|
/// <param name="link">the path to the link to be created</param>
|
|
/// <param name="target">the path to the target file</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
bool CreateNativeHardLink(std::string link, std::string target);
|
|
/// <summary>
|
|
/// Create native hardlink to file
|
|
/// </summary>
|
|
/// <param name="hfile">A valid handle to the target file</param>
|
|
/// <param name="target">the path to the target file</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
bool CreateNativeHardLink(HANDLE hfile, std::wstring target);
|
|
/// <summary>
|
|
/// Create native hardlink to file
|
|
/// </summary>
|
|
/// <param name="hfile">A valid handle to the target file</param>
|
|
/// <param name="target">the path to the target file</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code</returns> 1
|
|
bool CreateNativeHardLink(HANDLE hfile, std::string target);
|
|
/// <summary>
|
|
/// Create reparse point
|
|
/// </summary>
|
|
/// <param name="hdir">A valid handle to a directory with FILE_WRITE_DATA_ACCESS</param>
|
|
/// <param name="target">the target of the reparse point</param>
|
|
/// <param name="printname">optional, the reparse point print name</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code </returns>
|
|
bool CreateMountPoint(HANDLE hdir, std::wstring target, std::wstring printname = L"");
|
|
/// <summary>
|
|
/// Create reparse point
|
|
/// </summary>
|
|
/// <param name="hdir">A valid handle to a directory with FILE_WRITE_DATA_ACCESS</param>
|
|
/// <param name="target">the target of the reparse point</param>
|
|
/// <param name="printname">optional, the reparse point print name</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code </returns>
|
|
bool CreateMountPoint(HANDLE hdir, std::string target, std::string printname = "");
|
|
/// <summary>
|
|
/// Create reparse point
|
|
/// </summary>
|
|
/// <param name="dir">path to a directory, the caller must ensure that the directory is empty</param>
|
|
/// <param name="target">the target of the reparse point</param>
|
|
/// <param name="printname">optional, the reparse point print name</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code </returns>
|
|
bool CreateMountPoint(std::wstring dir, std::wstring target, std::wstring printname = L"");
|
|
/// <summary>
|
|
/// Create reparse point
|
|
/// </summary>
|
|
/// <param name="dir">path to a directory, the caller must ensure that the directory is empty</param>
|
|
/// <param name="target">the target of the reparse point</param>
|
|
/// <param name="printname">optional, the reparse point print name</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code </returns>
|
|
bool CreateMountPoint(std::string dir, std::string target, std::string printname = "");
|
|
/// <summary>
|
|
/// remove reparse point tag from a directory
|
|
/// </summary>
|
|
/// <param name="hdir">valid handle to a directory with FILE_WRITE_DATA access</param>
|
|
/// <returns></returns>
|
|
bool DeleteMountPoint(HANDLE hdir);
|
|
/// <summary>
|
|
/// remove reparse point tag from a directory
|
|
/// </summary>
|
|
/// <param name="dir">Target path to the reparse point</param>
|
|
/// <returns></returns>
|
|
bool DeleteMountPoint(std::wstring dir);
|
|
/// <summary>
|
|
/// remove reparse point tag from a directory
|
|
/// </summary>
|
|
/// <param name="dir">Target path to the reparse point</param>
|
|
/// <returns></returns>
|
|
bool DeleteMountPoint(std::string dir);
|
|
/// <summary>
|
|
/// read the data in a reparse point
|
|
/// </summary>
|
|
/// <param name="hdir">A valid HANDLE with GENERIC_READ to the target directory</param>
|
|
/// <param name="">reserved must be L""</param>
|
|
/// <returns>Return the data of the reparse point if succeeded</returns>
|
|
std::wstring GetMountPointData(HANDLE hdir, std::wstring/*reserved specify L""*/);
|
|
/// <summary>
|
|
/// read the data in a reparse point
|
|
/// </summary>
|
|
/// <param name="hdir">A valid HANDLE with GENERIC_READ to the target directory</param>
|
|
/// <param name="">reserved must be L""</param>
|
|
/// <returns>Return the data of the reparse point if succeeded</returns>
|
|
std::string GetMountPointData(HANDLE hdir, std::string/*reserved specify L""*/);
|
|
/// <summary>
|
|
/// read the data in a reparse point
|
|
/// </summary>
|
|
/// <param name="dir">The path to the directory</param>
|
|
/// <returns>Return the data of the reparse point if succeeded</returns>
|
|
std::wstring GetMountPointData(std::wstring dir);
|
|
/// <summary>
|
|
/// read the data in a reparse point
|
|
/// </summary>
|
|
/// <param name="dir">The path to the directory</param>
|
|
/// <returns>Return the data of the reparse point if succeeded</returns>
|
|
std::string GetMountPointData(std::string dir);
|
|
|
|
/// Thanks to James Forshaw this wouldn't be possible without him
|
|
/// I actually copied the entire class with some minor changes
|
|
/// I am planning to to possibility to give an argument to the callback function
|
|
/// It's easy but I still have a lot to do
|
|
class FileOpLock
|
|
{
|
|
public:
|
|
|
|
typedef void(*UserCallback)();
|
|
static FileOpLock* CreateLock(HANDLE h, FileOpLock::UserCallback cb);
|
|
void WaitForLock(UINT Timeout);
|
|
|
|
~FileOpLock();
|
|
private:
|
|
|
|
HANDLE g_hFile;
|
|
OVERLAPPED g_o;
|
|
REQUEST_OPLOCK_INPUT_BUFFER g_inputBuffer;
|
|
REQUEST_OPLOCK_OUTPUT_BUFFER g_outputBuffer;
|
|
HANDLE g_hLockCompleted;
|
|
PTP_WAIT g_wait;
|
|
UserCallback _cb;
|
|
|
|
FileOpLock(UserCallback cb);
|
|
|
|
static void CALLBACK WaitCallback(PTP_CALLBACK_INSTANCE Instance,
|
|
PVOID Parameter, PTP_WAIT Wait,
|
|
TP_WAIT_RESULT WaitResult);
|
|
|
|
void DoWaitCallback();
|
|
|
|
bool BeginLock(HANDLE h);
|
|
|
|
};
|
|
/// <summary>
|
|
/// this function will create and wait the lock to trigger
|
|
/// </summary>
|
|
/// <param name="file">A path to the file to be locked, if it doesn't exist it will be created</param>
|
|
/// <param name="cb">Call back function</param>
|
|
/// <param name="IsDirectory">The file to be opened is it directory or not</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
bool CreateAndWaitLock(std::wstring file, _UserCallback cb = NULL, bool IsDirectory = false);
|
|
/// <summary>
|
|
/// this function will create and wait the lock to trigger
|
|
/// </summary>
|
|
/// <param name="file">A path to the file to be locked, if it doesn't exist it will be created</param>
|
|
/// <param name="cb">Call back function</param>
|
|
/// <param name="IsDirectory">The file to be opened is it directory or not</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
bool CreateAndWaitLock(std::string file, _UserCallback cb = NULL, bool IsDirectory = false);
|
|
/// <summary>
|
|
/// this function will create and wait the lock to trigger
|
|
/// </summary>
|
|
/// <param name="h">A valid HANDLE to the file to be locked, if it doesn't exist it will be created</param>
|
|
/// <param name="cb">Call back function</param>
|
|
/// <returns>return true if suceeded, if not call OpsMaster::GetLastError to will retrieve the error code</returns>
|
|
bool CreateAndWaitLock(HANDLE h, _UserCallback cb);
|
|
/// <summary>
|
|
/// Create lock to the appropriate file and will return a lock_ptr
|
|
/// </summary>
|
|
/// <param name="h">Valid HANDLE to the file to be locked</param>
|
|
/// <param name="cb">Call back function</param>
|
|
/// <returns>return a valid lock_ptr if succeeded</returns>
|
|
lock_ptr CreateLock(HANDLE h, _UserCallback cb = NULL);
|
|
/// <summary>
|
|
/// Create lock to the appropriate file and will return a lock_ptr
|
|
/// </summary>
|
|
/// <param name="file">Valid file path</param>
|
|
/// <param name="cb">Call back function</param>
|
|
/// <param name="IsDirectory">Is the target file directory</param>
|
|
/// <returns>return a valid lock_ptr if succeeded</returns>
|
|
lock_ptr CreateLock(std::wstring file, _UserCallback cb = NULL, bool IsDirectory = false);
|
|
/// <summary>
|
|
/// Create lock to the appropriate file and will return a lock_ptr
|
|
/// </summary>
|
|
/// <param name="file">Valid file path</param>
|
|
/// <param name="cb">Call back function</param>
|
|
/// <param name="IsDirectory">Is the target file directory</param>
|
|
/// <returns>return a valid lock_ptr if succeeded</returns>
|
|
lock_ptr CreateLock(std::string file, _UserCallback cb = NULL, bool IsDirectory = false);
|
|
/// <summary>
|
|
/// Move file to a temp directory
|
|
/// </summary>
|
|
/// <param name="h">A HANDLE to a file with DELETE access</param>
|
|
/// <param name="temp_location">The path to be used to move the file this can be either USE_USER_TEMP_DIR or USE_SYSTEM_TEMP_DIR or USE_CUSTOM_TEMP_DIR</param>
|
|
/// <param name="loc">If USE_CUSTOM_TEMP_DIR specified this one must a path to the temp location to be used</param>
|
|
/// <returns></returns>
|
|
bool MoveFileToTempDir(HANDLE h, DWORD temp_location = USE_USER_TEMP_DIR, std::wstring loc = L"");
|
|
/// <summary>
|
|
/// Move file to a temp directory
|
|
/// </summary>
|
|
/// <param name="file">A valid path to directory or file</param>
|
|
/// <param name="temp_location">The path to be used to move the file this can be either USE_USER_TEMP_DIR or USE_SYSTEM_TEMP_DIR or USE_CUSTOM_TEMP_DIR</param>
|
|
/// <param name="loc">If USE_CUSTOM_TEMP_DIR specified this one must a path to the temp location to be used</param>
|
|
/// <param name="IsDirectory">The path specified is it a directory or file, the default is file</param>
|
|
/// <returns></returns>
|
|
bool MoveFileToTempDir(std::wstring file, bool IsDirectory = false, DWORD temp_location = USE_USER_TEMP_DIR, std::wstring loc = L"");
|
|
/// <summary>
|
|
/// Move file to a temp directory
|
|
/// </summary>
|
|
/// <param name="file">A valid path to directory or file</param>
|
|
/// <param name="temp_location">The path to be used to move the file this can be either USE_USER_TEMP_DIR or USE_SYSTEM_TEMP_DIR or USE_CUSTOM_TEMP_DIR</param>
|
|
/// <param name="loc">If USE_CUSTOM_TEMP_DIR specified this one must a path to the temp location to be used</param>
|
|
/// <param name="IsDirectory">The path specified is it a directory or file, the default is file</param>
|
|
/// <returns></returns>
|
|
bool MoveFileToTempDir(std::string file, bool IsDirectory = false, DWORD temp_location = USE_USER_TEMP_DIR, std::string loc = "");
|
|
/// <summary>
|
|
/// Delete Child of a directory
|
|
/// </summary>
|
|
/// <param name="root">A handle to the root directory</param>
|
|
/// <param name="child">The child to be remove</param>
|
|
/// <returns></returns>
|
|
bool DeleteChild(HANDLE root, std::wstring child);
|
|
bool DeleteFileNative(std::wstring full_path);
|
|
bool DeleteFileNative(std::string full_path);
|
|
/// <summary>
|
|
/// Remove a directory recursively
|
|
/// </summary>
|
|
/// <param name="dir">directory name</param>
|
|
/// <returns></returns>
|
|
bool RRemoveDirectory(std::wstring dir);
|
|
/// <summary>
|
|
/// Remove a directory recursively
|
|
/// </summary>
|
|
/// <param name="dir">directory name</param>
|
|
/// <returns></returns>
|
|
bool RRemoveDirectory(std::string dir);
|
|
|
|
/// <summary>
|
|
/// change an entire token dos device (doesn't work well with impersonation)
|
|
/// and need some impovement
|
|
/// </summary>
|
|
/// <param name="device_path">Target dos device</param>
|
|
/// <param name="htoken">If impersonation needed, provide an impersonation token</param>
|
|
/// <param name="impersonate">must be true if impersonation required, otherwise must be set to false</param>
|
|
/// <returns></returns>
|
|
HANDLE SetTokenDosDevice(std::wstring device_path, HANDLE htoken = NULL);
|
|
HANDLE SetTokenDosDevice(std::string device_path, HANDLE htoken = NULL);
|
|
/// <summary>
|
|
/// generate a random string
|
|
/// </summary>
|
|
/// <param name="lenght">the lenght of the new string</param>
|
|
/// <returns></returns>
|
|
std::wstring GenerateRandomStr();
|
|
/// <summary>
|
|
/// delete a file by handle
|
|
/// </summary>
|
|
bool DeleteByHandle(HANDLE hfile);
|
|
/// <summary>
|
|
/// return a string that identify the current user sid
|
|
/// </summary>
|
|
std::wstring GetUserSid(HANDLE htoken = GetCurrentProcessToken());
|
|
|
|
/// Registry API
|
|
|
|
|
|
HANDLE RegCreateKeyNative(std::wstring target, DWORD desired_access = MAXIMUM_ALLOWED, bool OpenLink = true, bool CreateLink = false);
|
|
HANDLE RegCreateKeyNative(std::string target, DWORD desired_access = MAXIMUM_ALLOWED, bool OpenLink = true, bool CreateLink = false);
|
|
|
|
bool RegDeleteKeyNative(HANDLE hkey);
|
|
bool RegDeleteKeyNative(std::wstring target);
|
|
bool RegDeleteKeyNative(std::string target);
|
|
bool RegCreateNativeLink(HANDLE hkey, std::wstring target);
|
|
bool RegCreateNativeLink(HANDLE hkey, std::string target);
|
|
bool RegCreateNativeLink(std::wstring link, std::wstring target);
|
|
bool RegCreateNativeLink(std::string link, std::string target);
|
|
bool SetShortFileNameNative(HANDLE hfile, std::wstring short_name);
|
|
bool SetCaseSensitiveDirectory(HANDLE hf, bool enable = true);
|
|
//some will ask, where's the api to read/write registry
|
|
//I don't think those would be useful, I guess you can just use the standard api provided my MSFT
|
|
|
|
/////// some useful process API
|
|
|
|
|
|
/// <summary>
|
|
/// Open a process
|
|
/// </summary>
|
|
/// <param name="PID">Target Process PID</param>
|
|
/// <param name="access_mask">Desired access, default = MAXIUM_ALLOWED</param>
|
|
/// <returns>return a valid HANDLE if succeeded other it return nullptr</returns>
|
|
HANDLE OpenProcessNative(DWORD PID, DWORD access_mask = MAXIMUM_ALLOWED);
|
|
/// <summary>
|
|
/// Suspend a process
|
|
/// </summary>
|
|
/// <param name="hproc">A HANDLE to the process</param>
|
|
/// <returns>return true if succeeded otherwise it return false</returns>
|
|
bool SuspendProcess(HANDLE hprocess);
|
|
/// <summary>
|
|
/// Resume a process
|
|
/// </summary>
|
|
bool ResumeProcess(HANDLE hprocess);
|
|
/// <summary>
|
|
/// Terminate a process by it's id
|
|
/// </summary>
|
|
/// <param name="process_id">The process id to be terminated</param>
|
|
/// <returns>return true if succeeded otherwise false</returns>
|
|
bool TerminateProcessNative(DWORD process_id);
|
|
/// <summary>
|
|
/// Terminate a process by it's id
|
|
/// </summary>
|
|
/// <param name="hprocess">A HANDLE to the terminated process</param>
|
|
/// <returns></returns>
|
|
bool TerminateProcessNative(HANDLE hprocess);
|
|
/// <summary>
|
|
/// Get an anonymous logon token
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
HANDLE GetAnonymousToken();
|
|
|
|
//some obj manager functions
|
|
|
|
/// <summary>
|
|
/// Create a non persistent native directory in object manager
|
|
/// </summary>
|
|
/// <param name="dir">Path to the dir to be created</param>
|
|
/// <returns></returns>
|
|
HANDLE CreateObjDir(std::wstring dir);
|
|
/// <summary>
|
|
/// Create a non persistent native directory in object manager
|
|
/// </summary>
|
|
/// <param name="dir">Path to the dir to be created</param>
|
|
/// <returns></returns>
|
|
HANDLE CreateObjDir(std::string dir);
|
|
/// <summary>
|
|
/// Open HANDLE to object manager directory with MAXIMUM_ALLOWED access
|
|
/// </summary>
|
|
/// <param name="dir">Path to the dir to be opened</param>
|
|
/// <returns></returns>
|
|
HANDLE OpenObjDir(std::wstring dir);
|
|
/// <summary>
|
|
/// Open HANDLE to object manager directory with MAXIMUM_ALLOWED access
|
|
/// </summary>
|
|
/// <param name="dir">Path to the dir to be opened</param>
|
|
/// <returns></returns>
|
|
HANDLE OpenObjDir(std::string dir);
|
|
/// <summary>
|
|
/// Make a permanent obj
|
|
/// </summary>
|
|
/// <param name="hobj"></param>
|
|
/// <returns></returns>
|
|
bool MakePermanentObj(HANDLE hobj);
|
|
/// <summary>
|
|
/// Make a temporary obj
|
|
/// </summary>
|
|
bool MakeTemporaryObj(HANDLE hobj);
|
|
/// <summary>
|
|
/// create a native symbolic link
|
|
/// </summary>
|
|
/// <param name="link">A valid path to a link, example: L"\\RPC CONTROL\\test"</param>
|
|
/// <param name="target">A valid path DOS device path to the target file or directory, example:L"\\??\\C:\\test"</param>
|
|
/// <returns>Return a HANDLE to the newly created symlink if succeeded, if not call OpsMaster::GetLastError to retrieve the error code</returns>
|
|
HANDLE CreateNativeSymlink(std::wstring link, std::wstring target);
|
|
/// <summary>
|
|
/// create a native symbolic link
|
|
/// </summary>
|
|
/// <param name="link">A valid path to a link, example: L"\\RPC CONTROL\\test"</param>
|
|
/// <param name="target">A valid path DOS device path to the target file or directory, example:L"\\??\\C:\\test"</param>
|
|
/// <returns>Return a HANDLE to the newly created symlink if succeeded, if not call OpsMaster::GetLastError to retrieve the error code</returns>
|
|
HANDLE CreateNativeSymlink(std::string link, std::string target);
|
|
/// <summary>
|
|
/// Define a DosDevice, this function can be used to create symbolic link
|
|
/// </summary>
|
|
/// <param name="link">Path to the link</param>
|
|
/// <param name="target">Path to the target</param>
|
|
/// <returns></returns>
|
|
bool CreateDosDeviceLink(std::wstring link, std::wstring target);
|
|
/// <summary>
|
|
/// Define a DosDevice, this function can be used to create symbolic link
|
|
/// </summary>
|
|
/// <param name="link">Path to the link</param>
|
|
/// <param name="target">Path to the target</param>
|
|
/// <returns></returns>
|
|
bool CreateDosDeviceLink(std::string link, std::string target);
|
|
/// <summary>
|
|
/// Remove a DosDevice symbolic link
|
|
/// </summary>
|
|
/// <param name="link">The path to the symlink to be removed</param>
|
|
/// <returns></returns>
|
|
bool RemoveDosDeviceLink(std::string link);
|
|
/// <summary>
|
|
/// Remove a DosDevice symbolic link
|
|
/// </summary>
|
|
/// <param name="link">The path to the symlink to be removed</param>
|
|
/// <returns></returns>
|
|
bool RemoveDosDeviceLink(std::wstring link);
|
|
|
|
|
|
|
|
//some additional useful functions here
|
|
|
|
std::wstring GetCurrentExeDir();
|
|
|
|
std::wstring GetCurrentExeDirWithFileAppended(std::wstring file);
|
|
private:
|
|
std::wstring RegPathToNative(LPCWSTR lpPath);
|
|
};
|
|
|