was macht dieser code genau?

#include <windows.h>
#include <stdio.h>
#include <direct.h>
#include <ntsecapi.h>

#define UNICODE
#define _UNICODE

typedef HINSTANCE (WINAPI *mytype_LoadLibraryA)(LPCTSTR);
typedef BOOL (WINAPI *mytype_FreeLibrary)(HMODULE);
typedef FARPROC (WINAPI *mytype_GetProcAddress)(HMODULE, LPCTSTR);
typedef FARPROC (WINAPI *mytype_Function)(char *);

OSVERSIONINFO osver;

typedef struct _addr_data
{
	LPVOID load_library;
	LPVOID free_library;
	LPVOID get_address;
	char  lib_name[256];
	char lib_function[256];
	char argument[1024];
} addr_data, *paddr_data;

extern "C"
{
NTSYSAPI
NTAPI
NtQuerySystemInformation (
	DWORD i,
    OUT PVOID SystemInformation,
    IN ULONG SystemInformationLength,
    OUT PULONG ReturnLength OPTIONAL
    );
} 

typedef LONG KPRIORITY;

typedef struct _SYSTEM_PROCESS_INFORMATION {
    ULONG NextEntryOffset;
    ULONG NumberOfThreads;
    LARGE_INTEGER SpareLi1;
    LARGE_INTEGER SpareLi2;
    LARGE_INTEGER SpareLi3;
    LARGE_INTEGER CreateTime;
    LARGE_INTEGER UserTime;
    LARGE_INTEGER KernelTime;
    UNICODE_STRING ImageName;
    KPRIORITY BasePriority;
    HANDLE UniqueProcessId;
    HANDLE InheritedFromUniqueProcessId;
    ULONG HandleCount;
    ULONG SpareUl2;
    ULONG SpareUl3;
    ULONG PeakVirtualSize;
    ULONG VirtualSize;
    ULONG PageFaultCount;
    ULONG PeakWorkingSetSize;
    ULONG WorkingSetSize;
    ULONG QuotaPeakPagedPoolUsage;
    ULONG QuotaPagedPoolUsage;
    ULONG QuotaPeakNonPagedPoolUsage;
    ULONG QuotaNonPagedPoolUsage;
    ULONG PagefileUsage;
    ULONG PeakPagefileUsage;
    ULONG PrivatePageCount;
} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;

DWORD GetProcessIdByName(char * procname)
{
	DWORD id;
	BOOL bo;
	ULONG l,size,shift,interval,k;
	BYTE * buffer;
	SYSTEM_PROCESS_INFORMATION proc;
	char name[256];
	char tempname[256]; 

	memmove(tempname,procname,256);

	id=0;
	l=0;
	size=20000;
	while(size<=1000000)
	{
		buffer=(BYTE *)malloc(size);
		memset(buffer,0x00,size);
		bo=NtQuerySystemInformation(5,buffer,size,&l);
		if(bo==0) break;
		free(buffer);
		size=size+20000;
	}
	if(l==0)
	{
		printf("Can't get process information\n");
		return 0;
	}
	shift=0;
	interval=1;
	while(shift<l && interval!=0)
	{
		memset(&proc,0x00,sizeof(SYSTEM_PROCESS_INFORMATION));
		memmove(&proc,buffer+shift,sizeof(SYSTEM_PROCESS_INFORMATION));
		memset(name,0x00,256);
		k=WideCharToMultiByte(CP_ACP,0,proc.ImageName.Buffer,(-1),name,256,NULL,NULL);

		if(strncmp(_strupr(name),_strupr(tempname),256)==0)
		{
			id=(DWORD)proc.UniqueProcessId;
			break;
		}

		interval=*(DWORD *)(buffer+shift);
		shift=interval+shift;
	}

	free(buffer);
	return id;
}

LPVOID data_pointer;
LPVOID data_pointer1;

mytype_LoadLibraryA my_LoadLibraryA;		//address for LoadLibraryA
mytype_FreeLibrary my_FreeLibrary;		//address for LoadLibraryA
mytype_GetProcAddress my_GetProcAddress;	//address for GetProcAddress

static void WINAPI my_function(void * address)
{
HINSTANCE hmod;
mytype_Function address1;
paddr_data my_addr_data;

mytype_LoadLibraryA my1_LoadLibraryA;
mytype_FreeLibrary my1_FreeLibrary;
mytype_GetProcAddress my1_GetProcAddress;

my_addr_data=(paddr_data)address;
my1_LoadLibraryA=(mytype_LoadLibraryA)((LPCTSTR)(my_addr_data->load_library));
my1_FreeLibrary=(mytype_FreeLibrary)((LPCTSTR)(my_addr_data->free_library));;
hmod=my1_LoadLibraryA((LPCTSTR)(my_addr_data->lib_name));
if(hmod!=0)
{
	my1_GetProcAddress=(mytype_GetProcAddress)((LPCTSTR)my_addr_data->get_address);
	address1=(mytype_Function)my1_GetProcAddress(hmod,(LPCTSTR)(my_addr_data->lib_function));
	if(address1!=0)
	{
		address1(my_addr_data->argument);
	}
}

my1_FreeLibrary(hmod);
}

static void WINAPI my_function_end(void * address)
{
}

int main(int argc, TCHAR** argv) 
{
  DWORD TargetPID;
  DWORD TargetTID=NULL;
  HANDLE hProcess, hmod;
  int j=0;
LPVOID pointer;
PVOID intruderaddress;
BOOL bo;
DWORD threadlength;
addr_data my_data;
ULONG l;
HINSTANCE hint;
char filename[1024];
char buff[1024];

memset(filename,0x00,1024);
memset(buff,0x00,1024);

//Get system version 
	memset(&osver,0x00,sizeof(OSVERSIONINFO));
	osver.dwOSVersionInfoSize =sizeof(OSVERSIONINFO);
	bo=GetVersionEx(&osver);

	if(osver.dwMajorVersion==5)	//Win2000
	{
		TargetPID=GetProcessIdByName("explorer.exe");
		if(TargetPID==0) return (-1);
	}
	else return (-1);

hint=LoadLibrary((LPCTSTR)"kernel32.dll");

memset(my_data.lib_name,0x00,256);
memset(my_data.lib_function,0x00,256);

my_data.load_library=GetProcAddress(hint,"LoadLibraryA");
my_data.free_library=GetProcAddress(hint,"FreeLibrary");
my_data.get_address=GetProcAddress(hint,"GetProcAddress");

strncpy(my_data.lib_name,"c:\\pure_lib.dll",256);	//path for dll for execution

	strncpy(my_data.lib_function,"function1",256);	//function name in dll
	_getcwd(my_data.argument,240);
	strncat(my_data.argument,"\\123.321",8);		//argument for function

threadlength=(PBYTE)&my_function_end-(PBYTE)&my_function;

l=0;
hProcess=OpenProcess(PROCESS_ALL_ACCESS,TRUE,TargetPID);
if(hProcess==0) return (-1);
l=GetLastError();
pointer=VirtualAllocEx(hProcess,0,threadlength,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
if(pointer==NULL)
{
	printf("Can't allocate memory for thread in process space\n");
	return 1;
}

data_pointer=VirtualAllocEx(hProcess,0,sizeof(addr_data),MEM_COMMIT,PAGE_EXECUTE_READWRITE);
if(pointer==NULL)
{
	printf("Can't allocate memory for thread data in process space\n");
	return 1;
}

intruderaddress=&my_function;
bo=WriteProcessMemory(hProcess,pointer,intruderaddress,threadlength,&l);
if(bo==NULL)
{
	printf("Can't write thread in process space\n");
	return 1;
}

bo=WriteProcessMemory(hProcess, data_pointer,&my_data,sizeof(addr_data),&l);
if(bo==NULL)
{
	printf("Can't write thread data in process space\n");
	return 1;
}

hmod=CreateRemoteThread(hProcess, NULL, threadlength, (unsigned long (__stdcall *)(void *))pointer, data_pointer, 0, &l);
l=WaitForSingleObject(hmod,2000);

	  CloseHandle(hmod);
      if(hProcess) CloseHandle(hProcess);

	  return 1;
}

bekomme leider ein: main.cpp(36) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
was heisst das?

cu

extern "C"
{
NTSTATUS 
NTAPI 
NtQuerySystemInformation ( IN DWORD i, 
			   OUT PVOID SystemInformation, 
			   IN ULONG SystemInformationLength, 
			   OUT PULONG ReturnLength OPTIONAL );
}

nun bekomme ich: main.obj : error LNK2019: unresolved external symbol _NtQuerySystemInformation@16 referenced in function "unsigned long __cdecl GetProcessIdByName(char *)" (?GetProcessIdByName@@YAKPAD@Z)

da fehlt wohl ne lib...hm

die erste Fehlermeldung bedeutete:
Eine Funktion braucht einen Rückgabetyp, und wenn es void ist, hauptsache da ist einer.
Unter C wurde als default int angenommen, was aber mit C++ wieder abgeschafft wurde.

Die 2. Fehlermeldung sagt, dass deine Änderung falsch war xD
Sie sagt nämlich, dass die Funktion, so wie du sie geändert hast nicht gefunden werden kann.

Außerdem wäre die korrekte Deklaration diese (zumindest laut MSDN):

extern "C" {
NTSTATUS WINAPI NtQuerySystemInformation(
  SYSTEM_INFORMATION_CLASS SystemInformationClass,
  PVOID SystemInformation,
  ULONG SystemInformationLength,
  PULONG ReturnLength
);
}

MfG DrakoXP

#pragma comment (lib, "ntdll.lib")

muss ich linken;)

cu

aber nun gibts ein problem bei:

hmod=CreateRemoteThread(hProcess, NULL, threadlength, (unsigned long (__stdcall *)(void *))pointer, data_pointer, 0, &l);

die explorer.exe stürzt ab;/

cu

* Der Trick mit my_function_end kann, muss aber nicht funktionieren (my_function_end kann irgendwo liegen)
* Keiner garantiert dir dass der Code den der Compiler für my_function generiert "position independent" ist (also keine absoluten Adressen enthält)
* Keiner garantiert dir dass der Code für my_function "am Stück" liegt

Die Lösung ist "my_function" selbst in Assembler zu schreiben, und zwar "position independent" und "am Stück", und den Assembler Code in ein Byte-Array zu packen. Also so dass das im fertigen Programm dann inetwa so aussieht:

char const my_function_code[] = { 1, 2, 3, ... };

Für "1, 2, 3, ..." musst du natürlich den Code der Funktion einsetzen.

* Keiner garantiert dir dass der Code den der Compiler für my_function generiert "position independent" ist (also keine absoluten Adressen enthält)

Das könnte doch nur passieren wenn der Kompiler lt. Einstellungen mehr Code generiert als wie in "my_function" drinsteht (Überlaufprüfungen oder sowas).
So wie "my_function" formuliert ist, hat der Kompiler "keine Veranlassung", absolute Adressen zu verwenden ?

Und da du es selbst ansprichst: im Debug-Modus wird zumindest MSVC Code generieren der "versteckt" andere Funktionen aufruft, wie z.B. _RTC_CheckEsp.

----

Worauf ich hinaus wollte: wenn man sicher sein möchte dass alles funktioniert muss man die Funktion in Assembler schreiben und selbst dafür sorgen dass "alles passt".