构建重启后依然可用的 Windows 服务

#define SERVICE_COMMAND_INSTALL L"Install"             // The command line argument                                                       // for installing the service
#define SERVICE_COMMAND_LAUNCHER L"ServiceIsLauncher"  // Launcher command for                                                       // NT service

/*RunHost*/
BOOL RunHost(LPWSTR HostExePath,LPWSTR CommandLineArguments){    WriteToLog(L"RunHost '%s'",HostExePath);
    STARTUPINFO startupInfo = {};    startupInfo.cb = sizeof(STARTUPINFO);    startupInfo.lpDesktop = (LPTSTR)_T("winsta0\\default");
    HANDLE hToken = 0;    BOOL bRes = FALSE;
    LPVOID pEnv = NULL;    CreateEnvironmentBlock(&pEnv, hToken, TRUE);
    PROCESS_INFORMATION processInfoAgent = {};    PROCESS_INFORMATION processInfoHideProcess = {};    PROCESS_INFORMATION processInfoHideProcess32 = {};
    if (PathFileExists(HostExePath))    {        std::wstring commandLine;        commandLine.reserve(1024);
        commandLine += L"\"";        commandLine += HostExePath;        commandLine += L"\" \"";        commandLine += CommandLineArguments;        commandLine += L"\"";
        WriteToLog(L"launch host with CreateProcessAsUser ...  %s",                     commandLine.c_str());
        bRes = CreateProcessAsUserW(hToken, NULL, &commandLine[0],               NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS |               CREATE_UNICODE_ENVIRONMENT | CREATE_NEW_CONSOLE |               CREATE_DEFAULT_ERROR_MODE, pEnv,            NULL, &startupInfo, &processInfoAgent);        if (bRes == FALSE)        {            DWORD   dwLastError = ::GetLastError();            TCHAR   lpBuffer[256] = _T("?");            if (dwLastError != 0)    // Don't want to see an                                     // "operation done successfully" error ;-)            {                ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,    // It's a system error                    NULL,                                      // No string to be                                                               // formatted needed                    dwLastError,                               // Hey Windows: Please                                                               // explain this error!                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Do it in the standard                                                               // language                    lpBuffer,              // Put the message here                    255,                   // Number of bytes to store the message                    NULL);            }            WriteToLog(L"CreateProcessAsUser failed - Command Line = %s Error : %s",                         commandLine, lpBuffer);        }        else        {            if (!writeStringInRegistry(HKEY_LOCAL_MACHINE,               (PWCHAR)SERVICE_REG_KEY, (PWCHAR)SERVICE_KEY_NAME, HostExePath))            {                WriteToLog(L"Failed to write registry");            }        }    }    else    {        WriteToLog(L"RunHost failed because path '%s' does not exists", HostExePath);    }    hPrevAppProcess = processInfoAgent.hProcess;        CloseHandle(hToken);    WriteToLog(L"Run host end!");
    return bRes;}

bool g_bLoggedIn = false;

#define EVENT_SUBSCRIBE_PATH    L"Security"#define EVENT_SUBSCRIBE_QUERY    L"Event/System[EventID=4624]"

class UserLoginListner{    HANDLE hWait = NULL;    HANDLE hSubscription = NULL;
public:    ~UserLoginListner()    {        CloseHandle(hWait);        EvtClose(hSubscription);    }
    UserLoginListner()    {        const wchar_t* pwsPath = EVENT_SUBSCRIBE_PATH;        const wchar_t* pwsQuery = EVENT_SUBSCRIBE_QUERY;
        hWait = CreateEvent(NULL, FALSE, FALSE, NULL);
        hSubscription = EvtSubscribe(NULL, NULL,            pwsPath, pwsQuery,            NULL,            hWait,            (EVT_SUBSCRIBE_CALLBACK)UserLoginListner::SubscriptionCallback,            EvtSubscribeToFutureEvents);        if (hSubscription == NULL)        {            DWORD status = GetLastError();
            if (ERROR_EVT_CHANNEL_NOT_FOUND == status)                WriteToLog(L"Channel %s was not found.\n", pwsPath);            else if (ERROR_EVT_INVALID_QUERY == status)                WriteToLog(L"The query \"%s\" is not valid.\n", pwsQuery);            else                WriteToLog(L"EvtSubscribe failed with %lu.\n", status);
            CloseHandle(hWait);        }    }

void WaitForUserToLogIn(){    WriteToLog(L"Waiting for a user to log in...");    WaitForSingleObject(hWait, INFINITE);    WriteToLog(L"Received a Logon event - a user has logged in");}

static DWORD WINAPI SubscriptionCallback(EVT_SUBSCRIBE_NOTIFY_ACTION action, PVOID       pContext, EVT_HANDLE hEvent){    if (action == EvtSubscribeActionDeliver)    {        WriteToLog(L"SubscriptionCallback invoked.");        HANDLE Handle = (HANDLE)(LONG_PTR)pContext;        SetEvent(Handle);    }
    return ERROR_SUCCESS;}

WriteToLog(L"Launch client\n"); // launch client ...{    UserLoginListner WaitTillAUserLogins;    WaitTillAUserLogins.WaitForUserToLogIn();}

//Function to run a process as active user from Windows servicevoid ImpersonateActiveUserAndRun(){    DWORD session_id = -1;    DWORD session_count = 0;    WTS_SESSION_INFOW *pSession = NULL;
    if (WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &pSession, &session_count))    {        WriteToLog(L"WTSEnumerateSessions - success");    }    else    {        WriteToLog(L"WTSEnumerateSessions - failed. Error %d",GetLastError());        return;    }    TCHAR szCurModule[MAX_PATH] = { 0 };
    GetModuleFileName(NULL, szCurModule, MAX_PATH);

    for (size_t i = 0; i < session_count; i++)    {        session_id = pSession[i].SessionId;        WTS_CONNECTSTATE_CLASS wts_connect_state = WTSDisconnected;        WTS_CONNECTSTATE_CLASS* ptr_wts_connect_state = NULL;        DWORD bytes_returned = 0;        if (::WTSQuerySessionInformation(            WTS_CURRENT_SERVER_HANDLE,            session_id,            WTSConnectState,            reinterpret_cast<LPTSTR*>(&ptr_wts_connect_state),            &bytes_returned))        {            wts_connect_state = *ptr_wts_connect_state;            ::WTSFreeMemory(ptr_wts_connect_state);            if (wts_connect_state != WTSActive) continue;        }        else        {            continue;        }
        HANDLE hImpersonationToken;        if (!WTSQueryUserToken(session_id, &hImpersonationToken))        {            continue;        }
        //Get the actual token from impersonation one        DWORD neededSize1 = 0;        HANDLE *realToken = new HANDLE;        if (GetTokenInformation(hImpersonationToken, (::TOKEN_INFORMATION_CLASS) TokenLinkedToken, realToken, sizeof(HANDLE), &neededSize1))        {            CloseHandle(hImpersonationToken);            hImpersonationToken = *realToken;        }        else        {            continue;        }        HANDLE hUserToken;        if (!DuplicateTokenEx(hImpersonationToken,            TOKEN_ASSIGN_PRIMARY | TOKEN_ALL_ACCESS | MAXIMUM_ALLOWED,            NULL,            SecurityImpersonation,            TokenPrimary,            &hUserToken))        {            continue;        }

        // Get user name of this process        WCHAR* pUserName;        DWORD user_name_len = 0;        if (WTSQuerySessionInformationW(WTS_CURRENT_SERVER_HANDLE, session_id, WTSUserName, &pUserName, &user_name_len))        {            //Now we got the user name stored in pUserName        }        // Free allocated memory                                 if (pUserName) WTSFreeMemory(pUserName);        ImpersonateLoggedOnUser(hUserToken);        STARTUPINFOW StartupInfo;        GetStartupInfoW(&StartupInfo);        StartupInfo.cb = sizeof(STARTUPINFOW);        PROCESS_INFORMATION processInfo;        SECURITY_ATTRIBUTES Security1;        Security1.nLength = sizeof SECURITY_ATTRIBUTES;        SECURITY_ATTRIBUTES Security2;        Security2.nLength = sizeof SECURITY_ATTRIBUTES;        void* lpEnvironment = NULL;
        // Obtain all needed necessary environment variables of the logged in user.        // They will then be passed to the new process we create.
        BOOL resultEnv = CreateEnvironmentBlock(&lpEnvironment, hUserToken, FALSE);        if (!resultEnv)        {            WriteToLog(L"CreateEnvironmentBlock - failed. Error %d",GetLastError());            continue;        }        std::wstring commandLine;        commandLine.reserve(1024);        commandLine += L"\"";        commandLine += szCurModule;        commandLine += L"\" \"";        commandLine += SERVICE_COMMAND_Launcher;        commandLine += L"\"";        WCHAR PP[1024]; //path and parameters        ZeroMemory(PP, 1024 * sizeof WCHAR);        wcscpy_s(PP, commandLine.c_str());
        // Next we impersonate - by starting the process as if the current logged in user, has started it        BOOL result = CreateProcessAsUserW(hUserToken,            NULL,            PP,            NULL,            NULL,            FALSE,            NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE,            NULL,            NULL,            &StartupInfo,            &processInfo);
        if (!result)        {            WriteToLog(L"CreateProcessAsUser - failed. Error %d",GetLastError());        }        else        {            WriteToLog(L"CreateProcessAsUser - success");        }        DestroyEnvironmentBlock(lpEnvironment);        CloseHandle(hImpersonationToken);        CloseHandle(hUserToken);        CloseHandle(realToken);        RevertToSelf();    }    WTSFreeMemory(pSession);}

std::wstring GetLoggedInUser(){    std::wstring user{L""};    WTS_SESSION_INFO *SessionInfo;    unsigned long SessionCount;    unsigned long ActiveSessionId = -1;
    if(WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE,                            0, 1, &SessionInfo, &SessionCount))    {        for (size_t i = 0; i < SessionCount; i++)        {            if (SessionInfo[i].State == WTSActive ||                SessionInfo[i].State == WTSConnected)            {                ActiveSessionId = SessionInfo[i].SessionId;                break;            }        }
        wchar_t *UserName;        if (ActiveSessionId != -1)        {            unsigned long BytesReturned;            if (WTSQuerySessionInformation(WTS_CURRENT_SERVER_HANDLE,                ActiveSessionId, WTSUserName, &UserName, &BytesReturned))            {                user = UserName;        // Now we have the logged in user name                WTSFreeMemory(UserName);                }        }        WTSFreeMemory(SessionInfo);    }    return user;}

/** * GetExePath() - returns the full path of the current executable. * * @param values - none. * @return a std::wstring containing the full path of the current executable. */std::wstring GetExePath(){    wchar_t buffer[65536];    GetModuleFileName(NULL, buffer, sizeof(buffer) / sizeof(*buffer));    int pos = -1;    int index = 0;    while (buffer[index])    {        if (buffer[index] == L'\\' || buffer[index] == L'/')        {            pos = index;        }        index++;    }    buffer[pos + 1] = 0;    return buffer;}

/** * WriteToLog() - writes formatted text into a log file, and on screen (console) * * @param values - formatted text, such as L"The result is %d",result. * @return - none */void WriteToLog(LPCTSTR lpText, ...){    FILE *fp;    wchar_t log_file[MAX_PATH]{L""};    if(wcscmp(log_file,L"") == NULL)    {        wcscpy(log_file,GetExePath().c_str());        wcscat(log_file,L"log.txt");    }    // find gmt time, and store in buf_time    time_t rawtime;    struct tm* ptm;    wchar_t buf_time[DATETIME_BUFFER_SIZE];    time(&rawtime);    ptm = gmtime(&rawtime);    wcsftime(buf_time, sizeof(buf_time) / sizeof(*buf_time), L"%d.%m.%Y %H:%M", ptm);
    // store passed messsage (lpText) to buffer_in    wchar_t buffer_in[BUFFER_SIZE];
    va_list ptr;    va_start(ptr, lpText);
    vswprintf(buffer_in, BUFFER_SIZE, lpText, ptr);    va_end(ptr);
    // store output message to buffer_out - enabled multiple parameters in swprintf    wchar_t buffer_out[BUFFER_SIZE];
    swprintf(buffer_out, BUFFER_SIZE, L"%s %s\n", buf_time, buffer_in);
    _wfopen_s(&fp, log_file, L"a,ccs=UTF-8");    if (fp)    {        fwprintf(fp, L"%s\n", buffer_out);        fclose(fp);    }    wcscat(buffer_out,L"\n");HANDLE stdOut = GetStdHandle(STD_OUTPUT_HANDLE);    if (stdOut != NULL && stdOut != INVALID_HANDLE_VALUE)    {        DWORD written = 0;        WriteConsole(stdOut, buffer_out, wcslen(buffer_out), &written, NULL);    }}

BOOL CreateRegistryKey(HKEY hKeyParent, PWCHAR subkey){    DWORD dwDisposition; //Verify new key is created or open existing key    HKEY  hKey;    DWORD Ret;    Ret =        RegCreateKeyEx(            hKeyParent,            subkey,            0,            NULL,            REG_OPTION_NON_VOLATILE,            KEY_ALL_ACCESS,            NULL,            &hKey,            &dwDisposition);    if (Ret != ERROR_SUCCESS)    {        WriteToLog(L"Error opening or creating new key\n");        return FALSE;    }    RegCloseKey(hKey); //close the key    return TRUE;}
BOOL writeStringInRegistry(HKEY hKeyParent, PWCHAR subkey,                           PWCHAR valueName, PWCHAR strData){    DWORD Ret;    HKEY hKey;    //Check if the registry exists    Ret = RegOpenKeyEx(        hKeyParent,        subkey,        0,        KEY_WRITE,        &hKey    );    if (Ret == ERROR_SUCCESS)    {        if (ERROR_SUCCESS !=            RegSetValueEx(                hKey,                valueName,                0,                REG_SZ,                (LPBYTE)(strData),                ((((DWORD)lstrlen(strData) + 1)) * 2)))        {            RegCloseKey(hKey);            return FALSE;        }        RegCloseKey(hKey);        return TRUE;    }    return FALSE;}
LONG GetStringRegKey(HKEY hKey, const std::wstring &strValueName,                     std::wstring &strValue, const std::wstring &strDefaultValue){    strValue = strDefaultValue;    TCHAR szBuffer[MAX_PATH];    DWORD dwBufferSize = sizeof(szBuffer);    ULONG nError;    nError = RegQueryValueEx(hKey, strValueName.c_str(), 0, NULL,             (LPBYTE)szBuffer, &dwBufferSize);    if (nError == ERROR_SUCCESS)    {        strValue = szBuffer;        if (strValue.front() == _T('"') && strValue.back() == _T('"'))        {            strValue.erase(0, 1); // erase the first character            strValue.erase(strValue.size() - 1); // erase the last character        }    }    return nError;}
BOOL readStringFromRegistry(HKEY hKeyParent, PWCHAR subkey,                            PWCHAR valueName, std::wstring& readData){    HKEY hKey;    DWORD len = 1024;    DWORD readDataLen = len;    PWCHAR readBuffer = (PWCHAR)malloc(sizeof(PWCHAR) * len);    if (readBuffer == NULL)        return FALSE;    //Check if the registry exists    DWORD Ret = RegOpenKeyEx(        hKeyParent,        subkey,        0,        KEY_READ,        &hKey    );    if (Ret == ERROR_SUCCESS)    {        Ret = RegQueryValueEx(            hKey,            valueName,            NULL,            NULL,            (BYTE*)readBuffer,            &readDataLen        );        while (Ret == ERROR_MORE_DATA)        {            // Get a buffer that is big enough.            len += 1024;            readBuffer = (PWCHAR)realloc(readBuffer, len);            readDataLen = len;            Ret = RegQueryValueEx(                hKey,                valueName,                NULL,                NULL,                (BYTE*)readBuffer,                &readDataLen            );        }        if (Ret != ERROR_SUCCESS)        {            RegCloseKey(hKey);            return false;;        }        readData = readBuffer;        RegCloseKey(hKey);        return true;    }    else    {        return false;    }}

  case WM_TIMER:        {            if (is_running) break;            WriteToLog(L"Timer event");            is_running = true;            HANDLE hProcessSnap;            PROCESSENTRY32 pe32;            bool found{ false };
            WriteToLog(L"Enumerating all processess...");            // Take a snapshot of all processes in the system.            hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);            if (hProcessSnap == INVALID_HANDLE_VALUE)            {                WriteToLog(L"Failed to call CreateToolhelp32Snapshot(). Error code %d",GetLastError());                is_running = false;                return 1;            }
            // Set the size of the structure before using it.            pe32.dwSize = sizeof(PROCESSENTRY32);
            // Retrieve information about the first process,            // and exit if unsuccessful            if (!Process32First(hProcessSnap, &pe32))            {                WriteToLog(L"Failed to call Process32First(). Error code %d",GetLastError());                CloseHandle(hProcessSnap);          // clean the snapshot object                is_running=false;                break;            }
            // Now walk the snapshot of processes, and            // display information about each process in turn            DWORD svchost_parent_pid = 0;            DWORD dllhost_parent_pid = 0;            std::wstring szPath = L"";
            if (readStringFromRegistry(HKEY_LOCAL_MACHINE, (PWCHAR)SERVICE_REG_KEY, (PWCHAR)SERVICE_KEY_NAME, szPath))            {                m_szExeToFind = szPath.substr(szPath.find_last_of(L"/\\") + 1);    // The process name is the executable name only                m_szExeToRun = szPath;                                            // The executable to run is the full path            }            else            {                WriteToLog(L"Error reading ExeToFind from the Registry");            }
            do            {                if (wcsstr( m_szExeToFind.c_str(), pe32.szExeFile))                {                    WriteToLog(L"%s is running",m_szExeToFind.c_str());                    found = true;                    is_running=false;                    break;                }                if (!g_bLoggedIn)                {                    WriteToLog(L"WatchDog isn't starting '%s' because user isn't logged in",m_szExeToFind.c_str());                    return 1;                }            }            while (Process32Next(hProcessSnap, &pe32));            if (!found)            {                WriteToLog(L"'%s' is not running. Need to start it",m_szExeToFind.c_str());                if (!m_szExeToRun.empty())    // watchdog start the host app                {                    if (!g_bLoggedIn)                    {                        WriteToLog(L"WatchDog isn't starting '%s' because user isn't logged in",m_szExeToFind.c_str());                        return 1;                    }                    ImpersonateActiveUserAndRun();
                    RunHost((LPWSTR)m_szExeToRun.c_str(), (LPWSTR)L"");
                }                else                {                    WriteToLog(L"m_szExeToRun is empty");                }            }            CloseHandle(hProcessSnap);        }        is_running=false;        break;

sc stop sg_revealerservicesc delete sg_revealerservicetaskkill /f /im sampleapp.exetaskkill /f /im sg_revealerservice.exe