EMPEZAR A CODEAR TU PROPIO CHEAT (Half

para aprender a hacer hacks para un determinado juego tenés que tener los archivos del sdk del juego y tratar de entender como funciona, desp aprendete rápido algo de c++ lo básico como crear programas básicos, la sintaxis, y lo que más puedas, desp estudiate la base del ogc, y cuando entiendas esa agarrá esa o sino otra más simple y trata de crearte un cheat nuevo a partir de esa..... leete los tutoriales estos que están en este post, y ahora voy a tratar de agregar más cosas.......... las dudas podés postearlas acá pero acordate que este foro es de coding en c++ entonces hablemos de código un poco tmb.....
sabete de hooking a funciones, inyección dll, y lo más que puedas de winapi y desp lo que complemente que vos creas

hola me encanta este post yo desde hace un tiempo trataba de crear cheats o hacks como le digan y no sabia casi nada ahora se bastante gracias a ustedes estuve tratando de crear lo primero para empezar crear el loader o inyector de la dll y tengo estos códigos sacados de este lugar y necesito ayuda porque los he compilado pero no parecen inyectar nada en el counter pero a su vez tampoco me dan errores, es muy confuso y quisiera que anden me pueden ayudar con esto se los agradezco mucho y muy buen foro este

injector1.cpp

Código:

#include <windows.h>
#include "iostream.h"
#include "stdio.h"

int WINAPI InjectLib(DWORD pid, char *laDll)
{

HANDLE proc;
char buf[MAX_PATH]="";
LPVOID RemoteString;
LPVOID nLoadLibrary;

proc = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
nLoadLibrary = (LPVOID)GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");

RemoteString = (LPVOID)VirtualAllocEx(proc,NULL,strlen(laDll),MEM _COMMIT|MEM_RESERVE,PAGE_READWRITE);

WriteProcessMemory(proc,(LPVOID)RemoteString,laDll ,strlen(laDll),NULL);

CreateRemoteThread(proc,NULL,NULL,(LPTHREAD_START_ ROUTINE)nLoadLibrary,(LPVOID)RemoteString,NULL,NUL L);

CloseHandle(proc);
return 1;
}

int main(int argc, char *argv[])
{
DWORD pid;
HWND hCS;

printf("waiting Half Life...\n");
while(1)
{
hCS = FindWindow("Valve001",NULL);
Sleep(300);

if(hCS!=NULL)break;
}
printf("Injecting...\n");
GetWindowThreadProcessId(hCS,&pid);
InjectLib(pid,"hack.dll");
return 1;
}

---------------------

injector2.cpp

Código:

#include <windows.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#define GAME "Counter-Strike"
#define DLL "hack.dll"

using namespace std;

HWND hWnd;
DWORD pId;

void Inject(HWND hWnd, char* strDll )
{
GetWindowThreadProcessId(hWnd, &pId);
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pId);
LPVOID lpRemoteAddress = VirtualAllocEx(hProcess, NULL, strlen(strDll), MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(hProcess, lpRemoteAddress, (LPVOID)strDll, strlen(strDll), NULL);
CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHa ndle("kernel32.dll"), "LoadLibraryA"), lpRemoteAddress, 0, NULL);
}

int main()
{
cout<<"waiting window to appear ";
while(!(hWnd = FindWindow(0,GAME))) Sleep(100);
cout<<"window found!"<<endl;
ofstream filecheck;
filecheck.open(DLL,ios::in);
if(!filecheck.is_open()) printf("Error: cant find %s.n",DLL);
else { Inject(hWnd,DLL); cout<<"Injected "<<DLL<<" into process!"<<endl;}
filecheck.close();
system("PAUSE");
return 0;
}

------------------------------

injector3.cpp

Código:

#include "injector3.h"

int Inyect(HANDLE Hand,char dll[])
{
if (Hand==NULL || dll == NULL) return 0;

HANDLE hThread;
HMODULE hKernel;
LPVOID loadl;
PVOID amem;
int dll2 = strlen(dll) + 1;

hKernel = GetModuleHandle("kernel32.dll");
loadl = (LPVOID)GetProcAddress(hKernel, "LoadLibraryA");
amem = (LPVOID)VirtualAllocEx(Hand,NULL, dll2, MEM_COMMIT,PAGE_READWRITE);

WriteProcessMemory(Hand,(LPVOID)amem,dll,dll2,NULL );
hThread = CreateRemoteThread(Hand,NULL,0,(LPTHREAD_START_ROU TINE)loadl,(LPVOID) amem,0,NULL);
CloseHandle(Hand);
return 1;
}

int main(int argc,char* argv[])
{
if (!Detect("hl.exe"))
{
Msg(" hl.exe not found cannot inject !","Error !");
}
if (Detect("hl.exe"))
{
Msg("App detected !","Detected !"); // hl is part of the fullname, because of the strstr, so it is hl.exe
Sleep(0x7d0);
Inyect(Detect("hl.exe"),"hack.dll");
}
return 0;
}

injector3.h

Código:

#include <windows.h>
#include "psapi.h"
#pragma comment (lib, "psapi")

// the lib in dev-cpp is libpsapi.a

#ifndef MAX_PID
#define MAX_PID 0x64
#endif

typedef struct iDetect{
DWORD PIDs[MAX_PID];
DWORD BytesReturned;
DWORD BytesRequired;
HANDLE hProcess;
HMODULE hMod;
char* FileName;
int TotalPIDs;
int aux;
} iDetect;

// =================================== DETECT ================================

HANDLE Detect(char* proc)
{
iDetect* Data = (iDetect*) malloc(sizeof(iDetect));
HANDLE ret = NULL;
Data->FileName = (char*) malloc(MAX_PATH);
char* pProc = (char*) malloc(lstrlen(proc));

if (!EnumProcesses(Data->PIDs,sizeof(DWORD)*MAX_PID,&Data->BytesReturned))
{

free(Data->FileName);
free(Data->PIDs);
free(Data);
return NULL;
}
Data->TotalPIDs = (Data->BytesReturned) / (sizeof(DWORD));
for(Data->aux=Data->TotalPIDs;Data->aux>0;Data->aux--)
{
Data->hProcess = OpenProcess(
PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
FALSE, Data->PIDs[Data->aux]);

if (Data->hProcess!=NULL)
{
if (EnumProcessModules(Data->hProcess, &Data->hMod,
sizeof(Data->hMod), &Data->BytesRequired))
{
if (GetModuleBaseName(Data->hProcess,Data-> hMod,
Data->FileName,MAX_PATH) == 0x0) Data->FileName[0] = 0x0;
}
CharLower(Data->FileName);
CharLower(pProc);

if (strstr(Data->FileName,pProc))
{
ret = OpenProcess(PROCESS_ALL_ACCESS,false,Data->PIDs[Data->aux]);
break;
}
CloseHandle(Data->hProcess);
}
}
CloseHandle(Data->hProcess);
free(Data->FileName);
FreeLibrary(Data->hMod);
free(Data->hProcess);
free(Data->PIDs);
free(pProc);
free(Data);
return ret;
}

// ================================================== ====================

int Msg(char* Err,char* ErrTitle){
return MessageBoxEx(GetDesktopWindow(),Err,ErrTitle, MB_OK ,0x2c0a );
}

// ================================================== ====================

CÓDIGO del sXe disabler 4.4 for learning pass sXe ORGANNER
este código lo posteó organner en cp y lo pongo para que se vea como hizo para pasar la versión 4.4 del sXe ahora ya va por la 4.6 pero vale la pena para ver e ingeniársela para saltear este tipo de protecciones, y para aquellos interesados que preguntan del tema y quieran aprender a saltearse este tipo de protecciones en modo ring0.

dejo el code::::::::::::::

Código:

#include <NTDDK.h>
#include <WINDEF.h>
#include <NTIFS.h>
#include <STDIO.h>
#include <WINUSER.h>
#include "IOCTL.h"
#include "ZDisasm.h"

/*
[sXe Injected 4.4]
[32][7C90D793] - NtCreateSection
[35][7C90D7D2] - NtCreateThread *NEED*
[74][7C90DCFD] - NtOpenFile *NEED*
[7A][7C90DD7B] - NtOpenProcess *NEED*
[89][7C90DEB6] - NtProtectVirtualMemory
[AD][7C90E1AA] - NtQuerySystemInformation *NEED*
[D5][7C90E4F2] - NtSetContextThread
[FE][7C90E84F] - NtSuspendThread
[115][7C90EA32] - NtWriteVirtualMemory *NEED*
*/

__declspec(dllimport) PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTable;
__declspec(dllimport) _stdcall KeAddSystemServiceTable(PVOID, PVOID, PVOID, PVOID, PVOID);
PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTableShadow = NULL;

typedef struct _MODULE_ENTRY
{
LIST_ENTRY le_mod;
ULONG unknown[4];
ULONG base;
ULONG driver_start;
ULONG unk1;
UNICODE_STRING driver_Path;
UNICODE_STRING driver_Name;
} MODULE_ENTRY, *PMODULE_ENTRY;

const WCHAR DeviceNameBuffer[] = L"\\Device\\SXEDISABLER";
const WCHAR DeviceLinkBuffer[] = L"\\DosDevices\\SXEDISABLER";

PMODULE_ENTRY g_psLoadedModuleList = NULL;
PDEVICE_OBJECT g_RootkitDevice = NULL;
ULONG g_uProcessNameOffset = 0;
NTSTATUS ntStatus = 0;

UCHAR DetourCode[] = "\xE9\x00\x00\x00\x00";
INT DetourSize = 5;

DWORD dwNtCreateThread;
BYTE pbNtCreateThread[5];

DWORD dwNtOpenFile;
BYTE pbNtOpenFile[5];

DWORD dwNtOpenProcess;
BYTE pbNtOpenProcess[5];

DWORD dwNtQuerySystemInformation;
BYTE pbNtQuerySystemInformation[5];

DWORD dwNtSetContextThread;
BYTE pbNtSetContextThread[5];

DWORD dwNtSuspendThread;
BYTE pbNtSuspendThread[5];

DWORD dwNtWriteVirtualMemory;
BYTE pbNtWriteVirtualMemory[5];

//======================================================================================================
// DRIVER CODE
//======================================================================================================
ULONG GetProcessNameOffset( VOID )
{
ULONG i;

for(i = 0; i < 3 * PAGE_SIZE; i++)
{
if( !strncmp("System", (PCHAR)PsGetCurrentProcess() + i, strlen("System")) )
{
return i;
}
}

return 0;
}
//======================================================================================================
ULONG GetProcessName( PCHAR theName )
{
PEPROCESS curproc;
char* nameptr;
ULONG i;

if( g_uProcessNameOffset )
{
curproc = PsGetCurrentProcess();
nameptr = (PCHAR) curproc + g_uProcessNameOffset;
strncpy( theName, nameptr, 16 );
theName[ 16 ] = 0;
return TRUE;
}

return FALSE;
}
//======================================================================================================
VOID RestoreALL( VOID )
{
__asm
{
cli
push eax
mov eax, cr0
and eax, 0xFFFEFFFF
mov cr0, eax
pop eax
}

//NtCreateThread
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x35], pbNtCreateThread, DetourSize);
//NtOpenFile
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x74], pbNtOpenFile, DetourSize);
//NtOpenProcess
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x7A], pbNtOpenProcess, DetourSize);
//NtQuerySystemInformation
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xAD], pbNtQuerySystemInformation, DetourSize);
//NtSetContextThread
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xD5], pbNtSetContextThread, DetourSize);
//NtSuspendThread
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xFE], pbNtSuspendThread, DetourSize);
//NtWriteVirtualMemory
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x115], pbNtWriteVirtualMemory, DetourSize);

__asm
{
push eax
mov eax, cr0
or eax, not 0xFFFEFFFF
mov cr0, eax
pop eax
sti
}
}
//======================================================================================================
VOID PatchALL( VOID )
{
__asm
{
cli
push eax
mov eax, cr0
and eax, 0xFFFEFFFF
mov cr0, eax
pop eax
}

//NtCreateThread
RtlCopyMemory(pbNtCreateThread, KeServiceDescriptorTableShadow[0].ServiceTable[0x35], DetourSize);
*(DWORD*)(DetourCode+1) = dwNtCreateThread - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x35] + 5 );
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x35], DetourCode, DetourSize);

//NtOpenFile
RtlCopyMemory(pbNtOpenFile, KeServiceDescriptorTableShadow[0].ServiceTable[0x74], DetourSize);
*(DWORD*)(DetourCode+1) = dwNtOpenFile - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x74] + 5 );;
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x74], DetourCode, DetourSize);

//NtOpenProcess
RtlCopyMemory(pbNtOpenProcess, KeServiceDescriptorTableShadow[0].ServiceTable[0x7A], DetourSize);
*(DWORD*)(DetourCode+1) = dwNtOpenProcess - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x7A] + 5 );
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x7A], DetourCode, DetourSize);

//NtQuerySystemInformation
RtlCopyMemory(pbNtQuerySystemInformation, KeServiceDescriptorTableShadow[0].ServiceTable[0xAD], DetourSize);
*(DWORD*)(DetourCode+1) = dwNtQuerySystemInformation - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xAD] + 5 );
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xAD], DetourCode, DetourSize);

//NtSetContextThread
RtlCopyMemory(pbNtSetContextThread, KeServiceDescriptorTableShadow[0].ServiceTable[0xD5], DetourSize);
*(DWORD*)(DetourCode+1) = dwNtSetContextThread - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xD5] + 5 );
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xD5], DetourCode, DetourSize);

//NtSuspendThread
RtlCopyMemory(pbNtSuspendThread, KeServiceDescriptorTableShadow[0].ServiceTable[0xFE], DetourSize);
*(DWORD*)(DetourCode+1) = dwNtSuspendThread - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xFE] + 5 );
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0xFE], DetourCode, DetourSize);

//NtWriteVirtualMemory
RtlCopyMemory(pbNtWriteVirtualMemory, KeServiceDescriptorTableShadow[0].ServiceTable[0x115], DetourSize);
*(DWORD*)(DetourCode+1) = dwNtWriteVirtualMemory - ( (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x115] + 5 );
RtlCopyMemory(KeServiceDescriptorTableShadow[0].ServiceTable[0x115], DetourCode, DetourSize);

__asm
{
push eax
mov eax, cr0
or eax, not 0xFFFEFFFF
mov cr0, eax
pop eax
sti
}
}
//======================================================================================================
unsigned int getAddressOfShadowTable()
{
unsigned int i;
unsigned char *p;
unsigned int dwordatbyte;

p = (unsigned char*)KeAddSystemServiceTable;

for(i = 0; i < 4096; i++, p++)
{
__try
{
dwordatbyte = *(unsigned int*)p;
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
return 0;
}

if(MmIsAddressValid((PVOID)dwordatbyte))
{
if(memcmp((PVOID)dwordatbyte, &KeServiceDescriptorTable, 16) == 0)
{
if((PVOID)dwordatbyte == &KeServiceDescriptorTable)
{
continue;
}

return dwordatbyte;
}
}
}

return 0;
}
//======================================================================================================
BOOL getShadowTable()
{
KeServiceDescriptorTableShadow = (PSERVICE_DESCRIPTOR_TABLE)getAddressOfShadowTable();

if(KeServiceDescriptorTableShadow == NULL)
{
return FALSE;
}
else
{
return TRUE;
}
}
//=====================================================================================================
NTSTATUS DriverDeviceControl( PFILE_OBJECT FileObject, BOOLEAN Wait, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength, ULONG IoControlCode, PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject )
{
IoStatus->Status = STATUS_SUCCESS;
IoStatus->Information = 0;

switch( IoControlCode )
{
case IOCTL_DEVICE_INITIALIZE:
{
dwNtCreateThread = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x35];
dwNtOpenFile = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x74];
dwNtOpenProcess = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x7A];
dwNtQuerySystemInformation = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xAD];
dwNtSetContextThread = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xD5];
dwNtSuspendThread = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0xFE];
dwNtWriteVirtualMemory = (DWORD)KeServiceDescriptorTableShadow[0].ServiceTable[0x115];
break;
}
case IOCTL_DEVICE_DISABLE:
{
PatchALL();
break;
}
case IOCTL_DEVICE_RESTORE:
{
RestoreALL();
break;
}
default:
{
IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
}

return IoStatus->Status;
}
//======================================================================================================
DWORD FindPsLoadedModuleList(PDRIVER_OBJECT DriverObject)
{
PMODULE_ENTRY psReturnEntry = NULL;

if( !DriverObject )
return 0;

psReturnEntry = *((PMODULE_ENTRY*)((DWORD)DriverObject + 0x14));

return (DWORD)psReturnEntry;
}
//======================================================================================================
ULONG UnlinkDriverEntry(PDRIVER_OBJECT DriverObject)
{
if( g_psLoadedModuleList && DriverObject->DriverStart )
{
PMODULE_ENTRY pm_current = g_psLoadedModuleList;

while((PMODULE_ENTRY)pm_current->le_mod.Flink != g_psLoadedModuleList)
{
if ((pm_current->unk1 != 0x00000000) && (pm_current->driver_Path.Length != 0))
{
if((ULONG)DriverObject->DriverStart == pm_current->base)
{
*((PDWORD)pm_current->le_mod.Blink) = (DWORD)pm_current->le_mod.Flink;
pm_current->le_mod.Flink->Blink = pm_current->le_mod.Blink;
return 1;
}
}

pm_current = (MODULE_ENTRY*)pm_current->le_mod.Flink;
}
}

return 0;
}
//=====================================================================================================
NTSTATUS DriverDispatch( PDEVICE_OBJECT DeviceObject, PIRP Irp )
{
NTSTATUS ntStatus;
PIO_STACK_LOCATION irpStack;
PVOID inputBuffer;
PVOID outputBuffer;
ULONG inputBufferLength;
ULONG outputBufferLength;
ULONG ioControlCode;
UNICODE_STRING ucDevicelink;

ntStatus = Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
irpStack = IoGetCurrentIrpStackLocation (Irp);

inputBuffer = Irp->AssociatedIrp.SystemBuffer;
inputBufferLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;
outputBuffer = Irp->AssociatedIrp.SystemBuffer;
outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;

switch (irpStack->MajorFunction)
{
case IRP_MJ_CREATE:
{
break;
}
case IRP_MJ_SHUTDOWN:
{
break;
}
case IRP_MJ_CLOSE:
{
break;
}
case IRP_MJ_DEVICE_CONTROL:
{
if( IOCTL_TRANSFER_TYPE(ioControlCode) == METHOD_NEITHER )
{
outputBuffer = Irp->UserBuffer;
}

ntStatus = DriverDeviceControl( irpStack->FileObject, TRUE, inputBuffer, inputBufferLength, outputBuffer, outputBufferLength, ioControlCode, &Irp->IoStatus, DeviceObject );
break;
}
}

IoCompleteRequest( Irp, IO_NO_INCREMENT );
return ntStatus;
}
//=====================================================================================================
VOID DriverUnload( PDRIVER_OBJECT DriverObject )
{
UNICODE_STRING ucDeviceLink;
RtlInitUnicodeString( &ucDeviceLink, DeviceLinkBuffer );
IoDeleteSymbolicLink( &ucDeviceLink );
IoDeleteDevice(DriverObject->DeviceObject);
}
//=====================================================================================================
NTSTATUS DriverEntry( PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath )
{
INT i;
NTSTATUS ntStatus;
UNICODE_STRING ucDeviceName;
UNICODE_STRING ucDeviceLink;

g_psLoadedModuleList = (PMODULE_ENTRY)FindPsLoadedModuleList( DriverObject );
g_uProcessNameOffset = GetProcessNameOffset();

if( !g_psLoadedModuleList || !g_uProcessNameOffset || !getShadowTable() || !UnlinkDriverEntry(DriverObject) )
{
return STATUS_UNSUCCESSFUL;
}

RtlInitUnicodeString( &ucDeviceName, DeviceNameBuffer );
RtlInitUnicodeString( &ucDeviceLink, DeviceLinkBuffer );

ntStatus = IoCreateDevice(DriverObject, 0, &ucDeviceName, FILE_DEVICE_HACK, 0, TRUE, &g_RootkitDevice);

if( !NT_SUCCESS(ntStatus) )
{
IoDeleteDevice(DriverObject->DeviceObject);
return ntStatus;
}

ntStatus = IoCreateSymbolicLink(&ucDeviceLink, &ucDeviceName);

if( !NT_SUCCESS(ntStatus) )
{
IoDeleteDevice(DriverObject->DeviceObject);
return ntStatus;
}

for(i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
{
DriverObject->MajorFunction[i] = DriverDispatch;
}

DriverObject->DriverUnload = DriverUnload;

return STATUS_SUCCESS;
}
//=====================================================================================================

CODE BY ORGANNER

créditos: rootkit.com, zelda, loopnz

Cita de: El PrInTeRo en 12 Septiembre 2007, 06:19

estuve probando wallhacks, es decir buscando alguno que pueda a llegar a ser "perfect" y probé el wh de opterman ese que usa engfuncs, es bueno pero tira las fps, acá dejo uno que no me tira las fps pruébenlo ustedes, es puro opengl.

http://img61.¡mageshack.us/img61/4072/detrain0000kz5.jpg
http://img61.¡mageshack.us/img61/3491/detrain0003ui0.jpg

Código:

// hecho por sharkboy
if(!(mode==GL_TRIANGLES||mode==GL_TRIANGLE_STRIP||mode==GL_TRIANGLE_FAN||mode==GL_QUADS))
{
GLfloat curcol[4];
glGetFloatv(GL_CURRENT_COLOR, curcol);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glColor4f(curcol[0],curcol[1],curcol[2],0.5f);
glClearColor(0.0f,0.0f,0.0f,0.0f);
}

pglBegin(mode);

man.. que lenguaje es el code.. por ejemplo..digamos que es un estilo batch que no es compilable.. lo tendrias que poner en un notepad lo guardas en .bat y ya estaria el wh o me equivoco.. responde pls.

Seguro seguo.. lo veo algo imcompleto a ese code. pero lo probare...

claro que le falta codigo, eso va dentro de la funcion que reemplaza el glbegin original.

Que tal hace tiempo viendo mirando el tema de sxe injected la verdad no se programar sin un libro de vc en la mano pero lei bastante sobre el tema y he buscado programas y lo mejor que me resulto era la inyecciones de .dll en modo oculto y gracias a eso eh podido chitiar varias versiones de sxe injected obiamente para la version 4.6 no he conseguido nada y mi pregunta era va si con el code de exon se podria saltar la ultima version de sxe 4.6 ya que no hace falta programar algo en ring 0 y demas la inyecciones de .dll en modo oculto funcionan bastante bien, aca dejo el post y me dicen haber que opinan
http://foro.elhacker.net/index.php?PHPSESSID=d91809f8720b31460914c2618c57f591&topic=186943.15

::)

saludos y realemnte me encata esta sección del foro tengo muchos hack chinos que por ahi estuve viendo lo de lso caminos muy buenos por cierto
PD:Aca les dejo un inyector de .dll que tiene la opcion para inyectar en mode oculto que sirvio para varias versiones de sxe inyecte oviamente ahora gen era un error que al parecer no alcanza inyectar bien .dll pero era muy bueno podias inyectar cualquier .dll que se te ocurra

http://rapidshare.com/files/99295331/Injector.rar

Me fije en las descargas y vi 15 descargas y nadie aporto nada muchachos no se les ocurre nada en base a ese inyector y si alguien me pudiera responder esa respuesta por favor gracias

man lo mejor que hay hasta ahora es este disabler que es un proyecto descontinuado kreo y es para saber como se puede pasar el sXe,

http://foro.elhacker.net/index.php/topic,176966.msg956299.html#msg956299
pero lo que pasa es que nadie sabe de kernelmode o casi nadie, y eso que no está documentado no vale porque hay bastantes cosas yo estuve viendo, o sino es porque no hay importancia en saltarlo pero eso es un aporte importante no te parece :laugh:

vos creo que debes chitearla y no encontraste nada para sXe en este foro por eso decís eso, pero ak en este post es más que nada para aklarar dudas y saber de que se trata todo esto y de como se programa y eso :¬¬

pero si no te quisiste decir eso entonces por qué decís que no hay descargas y eso no te entiendo a y eso del injector ese está bueno pero no tenemos el src aunke podemos figurar como está hecho pero de ahí a hacerlo hay un largo trecho xDDDDDDDDDDDDDDDDDD

PS; los hacks chinos xDDDDDDDDDDDDDD usando hacks con símbolos chinos haha tenías que adivinar las opciones del menú casi, pero chitear con las líneas estaba mortal >:D

yo estuve hablando con organner diciendome si habria otra forma de inyeccion distinta y me pase por pm el el code que vos pusiste del disabler que esta publicado en otra pag grande de cheats pero a lo que vboy si hay otra forma de pasar el sxe atraveas de inyeccion en modo oculto¡?

indetectable a que primeramente? a vac2 el sistema antichit legal de steam, bueno para eso te basta con usar un método de hooking nuevo, no público obviamente, y agregar code para esconder el módulo de tu dll de la memoria del juego así evitas ciertos escaneos, encripta el cheat, puedes agregar polimorfismo al cheat para que cambie y cambie el crc entonces no será detectable por mucho tiempo por el scan de vac2 de cheats conocidos..

indetectable a sXe bueno como sabes sXe trabaja en modo kernel con un hook ssdt de algunos servicios y con lo cual no puedes usar ciertas apis usadas por los cheats para inyectarse. tienes q programar en modo kernel tu propio hook ssdt u otro hook pero siempre restaurando las direcciones para que sXe no haga crash, claro que primero debes obtener las direcciones y eso, pero como ves los nuevos cheats para sXe 4.8 que están saliendo son todos similares con programación en modo kernel como te digo

hola queiro aprender a codear mi cheat espero que me ayuden

tengo VB 6.0

comencemos:

1. abre visual c++

2. File -> new y buscamos para hacer una "empty DLL"
(creo que es Win32 Dynamic-Link Library) llamaremos al proyecto opengl32

3. agregamos un nuevo archivo .cppand y lo llamamos main.cpp (creo que es C++Source File)

4. agregamos un nuevo archivo DEF (.def) (para este cree un block de notas con el nombre opengl32.txt y lo cambia a opengl32.def) y lo llamamos opengl32.def.

5. abrimos las propiedades del proyecto y linkeamos las siguientes librerías:
opengl32.lib glaux.lib glu32.lib ( aprete ALT+F7 fui ala pestania Link y en object/library modules puse opengl32.lib glaux.lib glu32.lib y aprete OK )

Por ahora esta bien o es major otra cosa bueno espero que me ayuden lean lo que puse con rojo y fijense si esta bien gracias seguire preguntando mas tarde

realmente el def no lo necesitas. en el DLL_PROCESS_ATTACH parcheas las funciones que necesite tu cheat. pero en vb no vas a poder hacerlo.

en heramientas dise VB :S si con VB C++ no puedo hacer el wall cual me combiene ??

yo tengo el VB 6.0 C++

herramientas: Visual C++ (5.0, 6.0 and 7.0/.Net recomendados)

y el .def lo nesesito para las librerias

opengl32.def:

este archivo contendrá todas las exportaciones que vas a necesitar de OpenGL.

LIBRARY opengl32
EXPORTS
glAccum
glAlphaFunc
glAreTexturesResident
glArrayElement
glBegin
glBindTexture
glBitmap
glBlendFunc
glCallList
glCallLists
glClear
glClearAccum
glClearColor
glClearDepth
glClearIndex
glClearStencil
glClipPlane
glColor3b
glColor3bv
glColor3d
glColor3dv
glColor3f
glColor3fv
glColor3i
glColor3iv
glColor3s
glColor3sv
glColor3ub
glColor3ubv
glColor3ui
glColor3uiv
glColor3us
glColor3usv
glColor4b
glColor4bv
glColor4d
glColor4dv
glColor4f
glColor4fv
glColor4i
glColor4iv
glColor4s
glColor4sv
glColor4ub
glColor4ubv
glColor4ui
glColor4uiv
glColor4us
glColor4usv
glColorMask
glColorMaterial
glColorPointer
glCopyPixels
glCopyTexImage1D
glCopyTexImage2D
glCopyTexSubImage1D
glCopyTexSubImage2D
glCullFace
glDeleteLists
glDeleteTextures
glDepthFunc
glDepthMask
glDepthRange
glDisable
glDisableClientState
glDrawArrays
glDrawBuffer
glDrawElements
glDrawPixels
glEdgeFlag
glEdgeFlagPointer
glEdgeFlagv
glEnable
glEnableClientState
glEnd
glEndList
glEvalCoord1d
glEvalCoord1dv
glEvalCoord1f
glEvalCoord1fv
glEvalCoord2d
glEvalCoord2dv
glEvalCoord2f
glEvalCoord2fv
glEvalMesh1
glEvalMesh2
glEvalPoint1
glEvalPoint2
glFeedbackBuffer
glFinish
glFlush
glFogf
glFogfv
glFogi
glFogiv
glFrontFace
glFrustum
glGenLists
glGenTextures
glGetBooleanv
glGetClipPlane
glGetDoublev
glGetError
glGetFloatv
glGetIntegerv
glGetLightfv
glGetLightiv
glGetMapdv
glGetMapfv
glGetMapiv
glGetMaterialfv
glGetMaterialiv
glGetPixelMapfv
glGetPixelMapuiv
glGetPixelMapusv
glGetPointerv
glGetPolygonStipple
glGetString
glGetTexEnvfv
glGetTexEnviv
glGetTexGendv
glGetTexGenfv
glGetTexGeniv
glGetTexImage
glGetTexLevelParameterfv
glGetTexLevelParameteriv
glGetTexParameterfv
glGetTexParameteriv
glHint
glIndexMask
glIndexPointer
glIndexd
glIndexdv
glIndexf
glIndexfv
glIndexi
glIndexiv
glIndexs
glIndexsv
glIndexub
glIndexubv
glInitNames
glInterleavedArrays
glIsEnabled
glIsList
glIsTexture
glLightModelf
glLightModelfv
glLightModeli
glLightModeliv
glLightf
glLightfv
glLighti
glLightiv
glLineStipple
glLineWidth
glListBase
glLoadIdentity
glLoadMatrixd
glLoadMatrixf
glLoadName
glLogicOp
glMap1d
glMap1f
glMap2d
glMap2f
glMapGrid1d
glMapGrid1f
glMapGrid2d
glMapGrid2f
glMaterialf
glMaterialfv
glMateriali
glMaterialiv
glMatrixMode
glMultMatrixd
glMultMatrixf
glNewList
glNormal3b
glNormal3bv
glNormal3d
glNormal3dv
glNormal3f
glNormal3fv
glNormal3i
glNormal3iv
glNormal3s
glNormal3sv
glNormalPointer
glOrtho
glPassThrough
glPixelMapfv
glPixelMapuiv
glPixelMapusv
glPixelStoref
glPixelStorei
glPixelTransferf
glPixelTransferi
glPixelZoom
glPointSize
glPolygonMode
glPolygonOffset
glPolygonStipple
glPopAttrib
glPopClientAttrib
glPopMatrix
glPopName
glPrioritizeTextures
glPushAttrib
glPushClientAttrib
glPushMatrix
glPushName
glRasterPos2d
glRasterPos2dv
glRasterPos2f
glRasterPos2fv
glRasterPos2i
glRasterPos2iv
glRasterPos2s
glRasterPos2sv
glRasterPos3d
glRasterPos3dv
glRasterPos3f
glRasterPos3fv
glRasterPos3i
glRasterPos3iv
glRasterPos3s
glRasterPos3sv
glRasterPos4d
glRasterPos4dv
glRasterPos4f
glRasterPos4fv
glRasterPos4i
glRasterPos4iv
glRasterPos4s
glRasterPos4sv
glReadBuffer
glReadPixels
glRectd
glRectdv
glRectf
glRectfv
glRecti
glRectiv
glRects
glRectsv
glRenderMode
glRotated
glRotatef
glScaled
glScalef
glScissor
glSelectBuffer
glShadeModel
glStencilFunc
glStencilMask
glStencilOp
glTexCoord1d
glTexCoord1dv
glTexCoord1f
glTexCoord1fv
glTexCoord1i
glTexCoord1iv
glTexCoord1s
glTexCoord1sv
glTexCoord2d
glTexCoord2dv
glTexCoord2f
glTexCoord2fv
glTexCoord2i
glTexCoord2iv
glTexCoord2s
glTexCoord2sv
glTexCoord3d
glTexCoord3dv
glTexCoord3f
glTexCoord3fv
glTexCoord3i
glTexCoord3iv
glTexCoord3s
glTexCoord3sv
glTexCoord4d
glTexCoord4dv
glTexCoord4f
glTexCoord4fv
glTexCoord4i
glTexCoord4iv
glTexCoord4s
glTexCoord4sv
glTexCoordPointer
glTexEnvf
glTexEnvfv
glTexEnvi
glTexEnviv
glTexGend
glTexGendv
glTexGenf
glTexGenfv
glTexGeni
glTexGeniv
glTexImage1D
glTexImage2D
glTexParameterf
glTexParameterfv
glTexParameteri
glTexParameteriv
glTexSubImage1D
glTexSubImage2D
glTranslated
glTranslatef
glVertex2d
glVertex2dv
glVertex2f
glVertex2fv
glVertex2i
glVertex2iv
glVertex2s
glVertex2sv
glVertex3d
glVertex3dv
glVertex3f
glVertex3fv
glVertex3i
glVertex3iv
glVertex3s
glVertex3sv
glVertex4d
glVertex4dv
glVertex4f
glVertex4fv
glVertex4i
glVertex4iv
glVertex4s
glVertex4sv
glVertexPointer
glViewport
wglChoosePixelFormat
wglCopyContext
wglCreateContext
wglCreateLayerContext
wglDeleteContext
wglDescribeLayerPlane
wglDescribePixelFormat
wglGetCurrentContext
wglGetCurrentDC
wglGetDefaultProcAddress
wglGetLayerPaletteEntries
wglGetPixelFormat
wglGetProcAddress
wglMakeCurrent
wglRealizeLayerPalette
wglSetLayerPaletteEntries
wglSetPixelFormat
wglShareLists
wglSwapBuffers
wglSwapLayerBuffers
wglUseFontBitmapsA
wglUseFontBitmapsW
wglUseFontOutlinesA
wglUseFontOutlinesW

hard-h2o modding Foros de ayuda Yashira.org Videojuegos indetectables.net

Noticias Informatica Seguridad Informática ADSL Foros en español eNYe Sec

Todas las webs afiliadas están libres de publicidad engañosa.