Mensajes

[no es lo que vos estás pidiendo]

Mirá esto no es lo que vos estás pidiendo, pero te puede dar alguna idea:

Código (cpp) [Seleccionar] Expandir



//
// By 85
// elhacker.net
// etalking.com.ar
// 2013
//

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma warning(disable: 4244)
#pragma warning(disable: 4390)
#include<windows.h> // SYSTEM (stdlib.h)
#include<stdio.h>
#include"ascii.h"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void Factorizar(int num){

int copia= num, m = 1, cifras = 1;
for(;copia>=10;copia/=10) cifras++;
for(int x=0;x<(cifras-1);x++) m*=10;
float v1=num;
int v2=0, v3=num;
for(int i=0; i<cifras; i++){//Descompone en factores

printf("%f\n",v1);
system("pause");
v1/=m;
v2=(int)v1*m;
v3-=v2;
m/=10;
v1=v3;
}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void IngresoInt(){

int n;
printf("Ingrese un número\n");
scanf("%d",&n);
Factorizar(n);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void Factorizar2(char* num){//TODO: Comprobación de ingreso no válido (ver ascii.h)

int sig=0;
if((sig=num[0]=='+')||(sig=num[0]=='-'));
int len=strlen(num);
int ac=0, v1, cifras = len,m = 1;
for(int x=0;x<((cifras-1)-sig);x++) m*=10;
for(int i=sig;i<cifras;i++){//Factoriza y acumula
v1=num[i]-'0';
v1*=m;
printf("%d\n",v1);
system("pause");
ac+=v1;
m/=10;
}
printf("%d\n",ac);
system("pause");
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void IngresoString(){

char n[256];
printf("Ingrese un número\n");
scanf("%s",n);
Factorizar2(n);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main(){

IngresoInt();
//IngresoString();
system("pause");
return 0;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


http://www.mediafire.com/?2or6l2m3p9jqzwa

otra cosa, es que si tenés que exponenciar consideres usar la función POW, aunque podés safar de usarla si querés hacer como en estas funciones mías.

88

Todas juntas? cuando juntás varias cadenas en 1, eso se le dice 'concatenar cadenas'. Se hace normalmente con STRCAT. No se si es lo que requerís, pero te lo digo solamente..

Esperá que alguno del foro se moleste en googlearlo y te diga, mientras tanto fijate esto:
http://www.cplusplus.com/reference/cstdio/printf/
http://www.cplusplus.com/reference/cstdio/scanf/

PS: Usa la opción de 'traducir' de tu navegador Chrome.

88

Lo que necesitás es almacenamiento para 10 enteros, por lo tanto por una cuestión de lógica , necesitás un espacio para 10 enteros.

Digo que son enteros al ver tu código.

tus posibilidades son usar un arreglo de 10 , o un buffer de asignación dinámica, o declarar 10 variables de enteros.
No creo que tu profesor te permita usar tantas variables, a menos que estás en un curso de ingreso XD

los 2. Pero Visual C++ es más fachero 

[7" pantalla Android 4.0 TOP configuración tablet pc]

Mi jefe es un hombre muy de moda, que siempre gusta ir de compras en Internet.Ayer cuando estaba listo para volver a casa, él me envió un mensajes de texto y escribió: "hola, Benny, sé que usted está buscando un tablet pc agradable, así que creo que debería recomendar esta tableta para usted.su configuración es muy bonito y está comenzando una promoción loco ahora, su nuevo precio es sólo del Euro € 52, creo que totalmente se lo puede permitir. "Ahora publicar esta noticia aquí, espero que sea útil!! enlace aquí: 7" pantalla Android 4.0 TOP configuración tablet pc

rico bot..

Me podes explicar donde consigo esta funcion? me interesa el tema.

Esta sería la implementación de la función de autoname.. Es un hack para Counter-Strike

Código [Seleccionar] Expandir


///////////////////////////////////////////////////////////////////////////////////////////////
//
//
// AUTONAME, NAMECHANGER, NAMESTEALER, TEST
// By 85
// [ElHacker.Net]
// [09/03/13]
//
//
///////////////////////////////////////////////////////////////////////////////////////////////

// Counter-Strike Base Hook
// By Chod & h1web
// Release Date: 26th October 2008

///////////////////////////////////////////////////////////////////////////////////////////////
#pragma optimize("gtp",on)
//#pragma comment(linker,"/MERGE:.data=.text /MERGE:.rdata=.text /SECTION:.text,EWR")

#include "apihook.h"
#include "include.h"

///////////////////////////////////////////////////////////////////////////////////////////////

char g_szBaseDir[ 256 ];
cl_enginefunc_t * o_pEngFuncs = NULL;

///////////////////////////////////////////////////////////////////////////////////////////////

void logme(char * fmt, ... )
{
va_list va_alist;
char buf[512];
va_start (va_alist, fmt);
_vsnprintf (buf, sizeof(buf), fmt, va_alist);
va_end (va_alist);

ofstream fout;
char path[256];
sprintf(path,"%sDionysus.txt",g_szBaseDir);
fout.open(path, ios::app);

if(fout.fail()) return;

fout << buf << endl;
fout.close();
}

///////////////////////////////////////////////////////////////////////////////////////////////

// This is just a test for the namechanger !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
bool ok=false;
static unsigned int randi=0;
static char names[32][256];
static unsigned int last_timer=0;
//extern cl_enginefunc_t * o_pEngFuncs;
void logme(char * fmt, ... );
////////////////////////////////////////////////////
void ModificadorDeNombresConSTR(char* str){

// Detección de doble whitespace
if(strstr(str,"  ")!=NULL)
    {
        strcpy(strstr(str,"  "),strstr(str,"  ")+1);
        return;
    }

// Detección de whitespace
if(strstr(str," ")!=NULL)
    {
        char buf[256];
        strcpy(buf,str);
        strcpy(strstr(buf," ")+1,strstr(str," "));
        strcpy(str,buf);
        return;
    }

// Char inicial y final iguales
    if(str[0]==str[strlen(str)-1])
    {
        char buf[256];
        char sbuf[2]="X";// Al asignarle valor se le agrega el 0 automáticamente.
        sbuf[0]=str[0];
        strcpy(buf,sbuf);
        strcat(buf,str);
        strcpy(str,buf);
        return;
    }

// Reemplazo de ocurrencias (para escritura 1337 XD)
if(strstr(str,"A")!=NULL)
    {
        *strstr(str,"A")='4';
        return;
    }

if(strstr(str,"B")!=NULL)
    {
        *strstr(str,"B")='5';
        return;
    }

if(strstr(str,"E")!=NULL)
    {
        *strstr(str,"E")='3';
        return;
    }

if(strstr(str,"G")!=NULL)
    {
        *strstr(str,"G")='6';
        return;
    }

if(strstr(str,"L")!=NULL)
    {
        *strstr(str,"L")='1';
        return;
    }

if(strstr(str,"O")!=NULL)
    {
        *strstr(str,"O")='0';
        return;
    }

if(strstr(str,"S")!=NULL)
    {
        *strstr(str,"S")='5';
        return;
    }

if(strstr(str,"T")!=NULL)
    {
        *strstr(str,"T")='7';
        return;
    }

// Char final y prefinal iguales
if(str[strlen(str)-1]==str[strlen(str)-2])
    {
        str[strlen(str)-1]=0;
        return;
    }

// Reducción de longitud
if(strlen(str)>16)
    {
        str[strlen(str)-1]=0;
        return;
    }

// Agrega un punto al final
strcat(str,".");
}


int AddEntResult = 1;
//===================================================================================
void HUD_AddEntity (int type, struct cl_entity_s *ent, const char *modelname)
{

if(o_pEngFuncs)
{
//////////////////////////////////////////////////////////////////Modificado por 85

if(o_pEngFuncs->GetLocalPlayer()->curstate.solid)
{
//logme("tgt %d",(timeGetTime()/1000));
//logme("last_timer %d",last_timer);
int ii = (timeGetTime()/1000);
SYSTEMTIME time;
GetLocalTime(&time);
//int ii =time.wSecond;
//int ii = 0;
//logme("o_pEngFuncs %X",o_pEngFuncs);
//logme("ii %d",ii);

if(((ii) - last_timer)>2.0)
{
int names_count=0;
int i;
for(i=0; i<33;i++)
{
cl_entity_s * pEnt = o_pEngFuncs->GetEntityByIndex(i);
if(pEnt && pEnt->curstate.solid && pEnt!=o_pEngFuncs->GetLocalPlayer())
{
hud_player_info_t pInfo;
o_pEngFuncs->pfnGetPlayerInfo(i, &pInfo);//pEnt->curstate.solid
char name[256];
//strcpy(name,pInfo.name);
memcpy(name,pInfo.name,128);
name[128]=0;
if(name[0]!='('){
randi++;
strcpy(names[names_count++],name);
}
}
}

int n;
if(names_count>0)
{
char cmdstr[256];
char name[256];
char buf[2]="A";
n=randi%names_count;
strcpy(cmdstr,"name \"");
strcpy(name,names[n]);
/////////////////////////////////////////////////
ModificadorDeNombresConSTR(name);// Hola, me reconocen?
//////////////////////////////////////////
strcat(cmdstr,name);
strcat(cmdstr,"\"");
o_pEngFuncs->pfnClientCmd(cmdstr);
//o_pEngFuncs->pfnDrawConsoleString( 300, 300, cmdstr );
//logme(cmdstr);
}

last_timer = (ii);
}
}///////////////////////////////////////////////////////////////
}///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////

int retval = 1;
AddEntResult = retval;
}
DWORD* slots=(DWORD*)0x01EB74E8;
static bool loaded = false;
static bool done = false;
DWORD retaddress;
__declspec( naked )void Gateway2_HUD_AddEntity( void )
{
__asm
{
mov AddEntResult, eax;
call HUD_AddEntity;
mov eax, AddEntResult;
jmp retaddress;
}
}
DWORD AddEnt = (DWORD)&Gateway2_HUD_AddEntity;
__declspec( naked )void Gateway1_HUD_AddEntity( void )
{

__asm
{
push esi;
mov esi,dword ptr ss:[esp+0x14];
mov retaddress,esi;
push AddEnt
pop esi;
mov dword ptr ss:[esp+0x14],esi;
pop esi;
ret;
}
}
__declspec(naked) void nullStub()
{
_asm ret;
}
void OnlyHook(LARGE_INTEGER *lp, bool force = true)
{
static bool patched = false;
bool a = (o_pEngFuncs->GetLocalPlayer()->curstate.solid && !done);
if( /*a ||*/force || GetAsyncKeyState(VK_END)&0x8000 )
{
unsigned char* c;
if(!patched)
{
patched=true;
for(int s=0;s<40;s++)
{
c = (unsigned char*)slots[s];
if( c[0] != 0xc3 )
{
patched=false;
MessageBox(NULL, "Things look wrong... very wrong", NULL, MB_OK);
}
}
}
c = (unsigned char*)slots[20];
if( c[0] == 0xc3 ){
slots[20] = (DWORD)&Gateway1_HUD_AddEntity;}//HUD_AddEntity
done = true;
}
if (force)
return;
}

typedef BOOL (WINAPI *QueryPerformanceCounterFunc)(LARGE_INTEGER*);
QueryPerformanceCounterFunc QueryPerformanceCounterPtr=NULL;
BOOL WINAPI newQueryPerformanceCounter(LARGE_INTEGER *lp)
{
BOOL  ret       = (*QueryPerformanceCounterPtr)(lp);
OnlyHook(lp, false);
return ret;
}

FARPROC (WINAPI *oGetProcAddress)(HMODULE hModule, LPCSTR lpProcName);

///////////////////////////////////////////////////////////////////////////////////////////////

FARPROC WINAPI _GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
{
FARPROC nResult = oGetProcAddress(hModule, lpProcName);

if (HIWORD(lpProcName))
{
if (!lstrcmp(lpProcName, "GetProcAddress"))
{
return (FARPROC) &_GetProcAddress;
}

else if(!strcmp(lpProcName,"QueryPerformanceCounter"))
        {
QueryPerformanceCounterPtr = (QueryPerformanceCounterFunc)nResult;
return (FARPROC)&newQueryPerformanceCounter;
        }
}

return nResult;
}

///////////////////////////////////////////////////////////////////////////////////////////////

BOOL APIENTRY DllMain ( HINSTANCE hInst, DWORD reason, LPVOID reserved )
{
    if( reason == DLL_PROCESS_ATTACH )
{
if(!o_pEngFuncs){
o_pEngFuncs=(cl_enginefunc_t *)0x01EB72D8;
}

// setup base directory
GetModuleFileName( hInst, g_szBaseDir, sizeof( g_szBaseDir ) );
char* pos = g_szBaseDir + strlen( g_szBaseDir );
while( pos >= g_szBaseDir && *pos!='\\' ) --pos; pos[ 1 ]=0;

oGetProcAddress=(FARPROC(WINAPI *)(HMODULE, LPCSTR))InterceptDllCall(GetModuleHandle(NULL), "Kernel32.dll", "GetProcAddress", (DWORD)&_GetProcAddress);
}
   
return TRUE;
}

///////////////////////////////////////////////////////////////////////////////////////////////




y me tomé la molestia de armarte un proyecto de una DLL para cargar en el juego, así podés probar de que se trata.
http://www.mediafire.com/?98pcz7qk8dwdswd

Ves los names que vas tomando?, son los de los demás pero con un cambio que lo hace la función esa.

Tenés que tener en cuenta que un proyecto Win32 pueden ser varias posibilidades, no sólo una aplicación con entorno gráfico, fijate



Visual Studio C++ 2010 por ejemplo

Una pregunta: ¿porque siempre incluyes windows.h en tus proyectos aunque no la uses?

En muchos de mis códigos está puesto innecesariamente, es cierto, pero si te tengo que responder ¿por qué? es entre otras razones por esto:

Algunas de las funciones que uso continuamente,

MessageBox (Depuramiento del programa)
http://msdn.microsoft.com/en-us/library/windows/desktop/ms645505(v=vs.85).aspx

GetAsyncKeyState (Para detectar alguna tecla)
http://msdn.microsoft.com/en-us/library/windows/desktop/ms646293(v=vs.85).aspx

ExitProcess (Salir del programa)
http://msdn.microsoft.com/en-us/library/windows/desktop/ms682658(v=vs.85).aspx

ETC

y es como que siempre queda <windows.h> 

Y como volcas todo esto al juego?

XD justo había apretado 'Publicar' y me dice que alguien respondió algo ERAS VOS XD

El tema es que en el juego hay una forma de obtener los datos de los jugadores, y a esta función solamente le tenés que pasar un nombre y te lo modifica. Con ese nombre modificado, ahora podés cambiar tu propio nombre al del modificado.

Voy a poner algo más a continuación para que no se haga tan largo el primer posteo XD, acerca del arreglo (FIX) con ensamblador en línea, yo había dicho que no se podía hacer con CALL, en realidad quise decir que no se podía hacer DIRECTAMENTE así como estaba la pila en esa situación.
Pero si arreglamos la pila si es posible de hecho lo acabo de hacer, y me pareció muy instructivo mostrárselos , veamos

Otra cosa, para hacer algo tan sencillo como esto quizás no haga falta tener que utilizar el depurador (OllyDBG por ejemplo), quiero decir, mucha gente que conozco nunca duda en ir directamente al OllyDBG si se trata de depurar algo, pero se que muchos programadores no recurren a este tipo de depuración DINÁMICA por así decirlo, sino más bien se quedan con una depuración NO DINÁMICA por así decirlo también, que se trata de solamente hacer que el programa se detenga y arroje resultados por pantalla, por archivo de texto o por MessageBox.
Para que se detenga el programa (lo que equivale a BreakPoint en el depurador), se puede usar un simple 'system("pause")', o un MessageBox que interrumpe el programa.

Volviendo al tema, sin necesidad de OllyDBG en esta ocasión, arreglé el code para que funcione con CALL. Este es el código que fue depurado con logs de información:

Código (cpp) [Seleccionar] Expandir


// DEPURAMIENTO POR MEDIO DE LOGs
int test1,test2,test3,test4,test5;
///////////////////////////////////////////////////////////////////////////////////////////////////////////

void __stdcall HOOK_glBegin(GLenum mode)
{
__asm mov eax, [esp+0x0] // calculado en esta posición
__asm mov glBegin_saved_ebp, eax // guardamos el ebp anterior
//////////////////////////////////////////////////////////////////

if(!once){

printf("\n");
printf("DLL -> HOOK_glBegin: ebp guardado!\n");
system("pause");
once=true;
}

if (mode==GL_POLYGON)
{
   glClearColor(1.0, 1.0, 1.0, 1.0);
   glColor3f(0, 0, 0);
}

//HIGH MEMORY (crece de arriba hacia abajo)
//EBP+08h   Primer Parámetro       //cmp dword ptr [ebp+0x8], 0x00000009 //mode
//EBP+04h   Direccion de retorno   // return address (0x401318 (EXE))
//EBP+0     Valor original de EBP // agregado
//LOW MEMORY

__asm mov eax, [ebp+0x4]
__asm mov test1, eax
__asm mov eax, [ebp+0x8]
__asm mov test2, eax

// printf("ret: 0x%X  arg: 0x%X\n",test1, test2);
// system("pause");

//__asm mov eax, ebp
//__asm mov test5, eax
//printf("test5: 0x%X  ebp: 0x%X\n",test5, glBegin_saved_ebp);
//system("pause");

//__asm add esp, 0x14 //0x10= deja esp en ret
__asm add esp, 0xc //deja esp sin los 3 valores iniciales (lista para recargarla)

   //__asm mov eax, [esp+0x0]
//__asm mov test5, eax
//printf("test5: 0x%X\n",test5);
//system("pause");

__asm mov ebp, glBegin_saved_ebp
__asm push test2
__asm call pOrig_glBegin
// __asm add esp, 0x4// llamada a glBegin (__stdcall), se encarga de limpiar la stack

//__asm mov eax, [ebp+0x4]
//__asm mov test3, eax
//__asm mov eax, [ebp+0x8]
//__asm mov test4, eax
//printf("ret: 0x%X  arg: 0x%X\n",test3, test4);
//system("pause");

//__asm mov eax, ebp
//__asm mov test5, eax
//printf("test5: 0x%X  ebp: 0x%X\n",test5, glBegin_saved_ebp);
//system("pause");


//__asm mov ebp, glBegin_saved_ebp
__asm push test1
//__asm ret 0x4
__asm ret

//__asm add esp, 0x4
//__asm jmp test1
//(*pOrig_glBegin)(mode);
}


En realidad no estoy diciendo que no se use OllyDBG, estoy diciendo que para una pabada como esta no hace falta, depende de lo que haga falta.
Por ejemplo, para este caso necesitamos saber los valores de ESP y EBP, y
de algún registro que usemos para guardar datos, por ejemplo EAX.
Aparte siempre tengo un explorador PE o un desensamblador a mano.

Como ya había dicho, la situación de la pila era algo así:

Código [Seleccionar] Expandir

HIGH MEMORY (crece de arriba hacia abajo)
EBP+08h   Primer Parámetro       //cmp dword ptr [ebp+0x8], 0x00000009 //mode
EBP+04h   Direccion de retorno   // return address (0x401318 (EXE))
EBP+0     Valor original de EBP // agregado (push ebp)
LOW MEMORY


con lo cual para llamar a CALL se debe pasar el parámetro de la función,  y CALL pone la dirección de retorno en la pila y al ejecutarse la función, se hace el ret limpiando dicha dirección. Como se trata de glBegin que es __stdcall, la propia función limpia el parámetro que estaba en la pila, por eso en realidad se hace ret 0x4.

El tema es que para llamar a CALL antes debía arreglarse la pila, por lo cual se borraron los 3 elementos iniciales (add esp, 0xC).
Luego se hace el CALL ya mencionado, se restaura el EBP modificado y por último se debe poner la dirección de retorno en la pila y hacer un ret. Fin de la historia.

Código (cpp) [Seleccionar] Expandir


int glBegin_saved_ebp;
int retaddress, param1;

///////////////////////////////////////////////////////////////////////////////////////////////////////////

void __stdcall HOOK_glBegin(GLenum mode)
{
//--------------------------------------
__asm mov eax, [esp+0x0] // calculado en esta posición
__asm mov glBegin_saved_ebp, eax // guardamos el ebp anterior
//--------------------------------------

if(!once){

printf("\n");
printf("DLL -> HOOK_glBegin: ebp guardado!\n");
system("pause");
once=true;
}

if (mode==GL_POLYGON)
{
   glClearColor(1.0, 1.0, 1.0, 1.0);
   glColor3f(0, 0, 0);
}

__asm mov eax, [ebp+0x4]
__asm mov retaddress, eax // copia de retaddress
__asm mov eax, [ebp+0x8]
__asm mov param1, eax // copia del parámetro 1
__asm add esp, 0xc //deja stack sin los 3 valores iniciales (lista para recargarla)

__asm mov ebp, glBegin_saved_ebp // restaura ebp
__asm push param1 // pasa parámetro 1
__asm call pOrig_glBegin // guarda dirección de retorno en stack y luego se hace pop en el ret
// __asm add esp, 0x4// llamada a glBegin (__stdcall), se encarga de limpiar la stack (ej: ret 0x4)

__asm push retaddress // pasa retaddress
__asm ret // vuelve al exe (pop retaddress)
//(*pOrig_glBegin)(mode);
}


Si quieren revisar el código nuevo:
http://www.mediafire.com/?bd45oh8qny515b2

Ya le encontré una utilidad a este ARREGLO o FIX con ASM. En otro momento voy a comentar de que se trata.


Hasta Luego

Siguiendo esa linea un ejercicio seria el calculo de la mediana: para encontrar el elemento al centro primero debe ordenar la lista.

----
Considerando que para obtener el tamaño de un tipo los paréntesis son obligatorios (con las expresiones no) me parece un error un tanto extraño (en algunos tutoriales).

Caso similar con las sentencias de retorno, frecuentemente se publican programas en estos foros utilizando paréntesis en la forma "return(N);". No se necesitan pero por alguna (extraña) razón los ponen.

Un saludo

AHAHAHAHAHAHA si RIR eso hace al codestyle de cada uno XD, ya se que lo decís por mi