Передача данных инжектированной длл

HANDLE WINAPI DetourOpenProcess(DWORD dwDesiredAccess, BOOL  bInheritHandle, DWORD dwProcessId)
{
    GetProcessNameFromPid(dwProcessId, lpPipeBufferWrite);
    
    WaitForSingleObject(hLocalMutex, INFINITE);
    
    if( CallNamedPipeW( lpNamePipe, lpPipeBufferWrite, BUFFER_SIZE, 
                lpPipeBufferRead, BUFFER_SIZE, 
                &BytesRead, NMPWAIT_NOWAIT) == FALSE )
            {
                // По какойто причине обломались или сервис молчит, чтобы ниче не зависло не вмешиваемся в работу
                ReleaseMutex(hLocalMutex);
                return fpOpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId);
            }
    
    if( !wcscmp(lpPipeBufferRead, L"STATUS_UNSUCCESSFUL") ) 
            {
                //Сервис ответил что нужно блокировать
                
                ReleaseMutex(hLocalMutex);
                SetLastError(ERROR_ACCESS_DENIED);
                return 0;
            }
    // сервис не обломался, не дал ответ что нужно было блокировать или вовсе мусор прилетел
    // то не вмешиваемся в работу.
    ReleaseMutex(hLocalMutex);
 
    return fpOpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId);     
    
}

    ghNamedPipe = CreateNamedPipeW(
        lpNamePipe,
        PIPE_ACCESS_DUPLEX,
        PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
        PIPE_UNLIMITED_INSTANCES,
        BUFFER_SIZE, BUFFER_SIZE, 5000, NULL);
 
    while( gServiceRunning ) 
    {
        if(ConnectNamedPipe(ghNamedPipe, NULL) == NULL) {
            break;
        }
 
        DWORD cbRead = 0;
 
        if(ReadFile(ghNamedPipe, lpPipeBufferRead, BUFFER_SIZE, &cbRead, NULL))
        {   
            //По умолчанию разрешаем работу
            wcscpy(lpPipeBufferWrite, L"STATUS_SUCCESSFUL");
            for(i = 0; i < Index; ++i)
                {
                    if(wcsstr(lpPipeBufferRead, szProcess[i]) != NULL) // Процесс в черном списке
                    {   
                        // Говорим что нужно блокировать
                        wcscpy(lpPipeBufferWrite, L"STATUS_UNSUCCESSFUL");
                        break;
                    }
                }
 
            даем ответ
            WriteFile(ghNamedPipe, lpPipeBufferWrite,BUFFER_SIZE, &cbRead, NULL);
        }
 
        DisconnectNamedPipe(ghNamedPipe);
    }
 
    CloseHandle(ghNamedPipe);

#include <windows.h>
#include <tchar.h>
 
#include <iostream>
 
#pragma comment(lib, "Setupapi.lib")
#pragma comment(lib, "advapi32.lib")
 
#define SVCNAME TEXT("LPSvc")
 
SERVICE_STATUS          gSvcStatus; 
SERVICE_STATUS_HANDLE   gSvcStatusHandle; 
volatile HANDLE         ghSvcStopEvent = NULL;
 
//volatile HANDLE           ghNamedPipe;
volatile HANDLE         ghServicecThread;
volatile BOOL           gServiceRunning;
 
 
 
VOID WINAPI SvcCtrlHandler( DWORD ); 
VOID WINAPI SvcMain( DWORD, LPTSTR * ); 
VOID ReportSvcStatus( DWORD dwCurrentState,
    DWORD dwWin32ExitCode,
    DWORD dwWaitHint);
DWORD ServiceExecutionThread( LPDWORD lpParam );
 
 
 
 
int __cdecl main(int argc, char *argv[]) 
{ 
 
    SERVICE_TABLE_ENTRY DispatchTable[] = 
    { 
        { SVCNAME, (LPSERVICE_MAIN_FUNCTION) SvcMain }, 
        { NULL, NULL } 
    }; 
 
 
    if (!StartServiceCtrlDispatcher( DispatchTable )) 
    { 
        printf("StartServiceCtrlDispatcher fail\n");
        return 0;
    } 
 
    return 0;
} 
 
 
VOID WINAPI SvcMain( DWORD dwArgc, LPTSTR *lpszArgv )
{
    
    gSvcStatusHandle = RegisterServiceCtrlHandler( 
        SVCNAME, 
        SvcCtrlHandler);
 
    if( !gSvcStatusHandle ) { 
        OutputDebugString(TEXT("LPSrv error -> RegisterServiceCtrlHandler"));
        return; 
    } 
 
    gSvcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; 
    gSvcStatus.dwServiceSpecificExitCode = 0;    
    ReportSvcStatus( SERVICE_START_PENDING, NO_ERROR, 3000 );
 
 
 
    ghSvcStopEvent = CreateEvent( NULL, TRUE, FALSE, NULL);   
 
    if ( ghSvcStopEvent == NULL)
    {
        OutputDebugString(TEXT("LPSrv error -> CreateEvent"));
        ReportSvcStatus( SERVICE_STOPPED, NO_ERROR, 0 );
        return;
    }
 
 
    ReportSvcStatus( SERVICE_RUNNING, NO_ERROR, 0 );
 
    DWORD id;
 
    gServiceRunning = TRUE;
    ghServicecThread = CreateThread( 0, 0, 
        (LPTHREAD_START_ROUTINE) ServiceExecutionThread,
        0, 0, &id );
 
    if(ghServicecThread == NULL) {
        OutputDebugString(TEXT("LPSrv error -> CreateThread"));
        return;
    }
 
    WaitForSingleObject(ghSvcStopEvent, INFINITE);
    CloseHandle(ghServicecThread);
}
 
 
VOID ReportSvcStatus( DWORD dwCurrentState,
    DWORD dwWin32ExitCode,
    DWORD dwWaitHint)
{
    static DWORD dwCheckPoint = 1;
 
    gSvcStatus.dwCurrentState = dwCurrentState;
    gSvcStatus.dwWin32ExitCode = dwWin32ExitCode;
    gSvcStatus.dwWaitHint = dwWaitHint;
 
    if (dwCurrentState == SERVICE_START_PENDING)
        gSvcStatus.dwControlsAccepted = 0;
    else gSvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
 
    if ( (dwCurrentState == SERVICE_RUNNING) ||
        (dwCurrentState == SERVICE_STOPPED) )
        gSvcStatus.dwCheckPoint = 0;
    else gSvcStatus.dwCheckPoint = dwCheckPoint++;
 
    SetServiceStatus( gSvcStatusHandle, &gSvcStatus );
}
 
 
VOID WINAPI SvcCtrlHandler( DWORD dwCtrl )
{
    DWORD BytesRead; TCHAR buff[1];
 
    switch(dwCtrl) 
    {  
    case SERVICE_CONTROL_SHUTDOWN:
    case SERVICE_CONTROL_STOP: 
        OutputDebugString(TEXT("LPSrv SERVICE_CONTROL_STOP|SERVICE_CONTROL_SHUTDOWN"));
        ReportSvcStatus(SERVICE_STOP_PENDING, NO_ERROR, 5000);
 
        gServiceRunning = FALSE;
        
        ///CallNamedPipeW( lpNamePipe, buff, 0, buff, 0, &BytesRead, NMPWAIT_NOWAIT);
 
        SetEvent(ghSvcStopEvent);
        ReportSvcStatus(SERVICE_STOPPED, NO_ERROR, 0);
 
        break;
 
    case SERVICE_CONTROL_INTERROGATE: 
        break; 
 
    default: 
        break;
    } 
 
    if( SetServiceStatus( gSvcStatusHandle, &gSvcStatus ) == FALSE) {
        OutputDebugString(TEXT("LPSrv error -> SetServiceStatus"));
    }
 
}
 
DWORD ServiceExecutionThread( LPDWORD lpParam )
{
 
    while( gServiceRunning ) 
    {
        // Здесь нужный код сервиса
    }
    return 0;
}