Mensajes

[EDIT]

Probaste con SendMessage? Si esas APIs no funcionan, puede que el juego esté usando DirectX? SI usa DirectX, la única forma es hookeando DirectInput. Creas tu propia función DirectInputCreate8() en una DLL tuya y la exportas. Esa función carga la DLL de DirectX original y hace de wrapper entre la original y el juego. Así inyectas todas las pulsaciones que quieras. Eso es si usa DirectX.

Saludos!

EDIT: Para captura de paquetes, hay muuuchos ejemplos. Te dejo 2 que parecen estar bastante completos: click, click2

Gracias por los post, ya los habia mirado pero voy a leer detenidametne sharpcap a ver si me mente me da para darle un uso en el mundo del hacking a esa libreria ,

te hago una consulta ya que me mencionas hacer hooks a traves de una dll.

tenes algun tuto o algo util de como hacer hooks a funciones desde una dll inyectada. pero en c#? todos los ejemplos que vi bien son de c++.

Por ahora mi camino esta  en : o me ponia con c++ a hacer una dll con function hooking, o trataba con sniffing y c#.

acepto cualquier recomendacion y consejo



Una de las cosas que me desconcerta de sharpPcap. que por lo q entiendo leyendo el articulo de codeplex.Captura los packetes que llegan a un device( una entrada de internet). mientras que yo lo q realmente necesito es q solo capte los packetes pertenecientes a un proceso( FuriusAo.exe ), no tengo idea como podria adaptarlo xd

MOD EDIT: No hagas doble post

Buenisimo, muchas gracias por la buena onda. Preguntare cosas puntuales. de cualquier manera si alguien con experiencia quiere contactarme y ayudarme con esto tmb seria ideal.


Puntualmente me gustaria algun ejemplo funcional de packet sniffing c# orientado al hacking.

Estuve mirando mucho del tema, y existen ejemplos en la web pero, muchos no funcionan. Ademas el codigo solo sin nadie que te lo explique o ayude se vuelve muy complicado.

Tema aparte: el servidor parece q bloquean los sendinputs. conocen alguna alternativa para enviar la tecla u que no sea sendinput o sendkeys?( esta es la razon por la que me quiero mover al packet sniffing

Ya, pero se consciente de que lo haces para beneficio propio y arruinar la experiencia de juego tanto tuya como la de los demás jugadores. Siempre he pensado que si a un juego le añades trucos pierde su gracia. Ojo, que los he usado alguna vez, pero que duran esas partidas? nada, te aburres porque el juego lo pierde todo.

Si algún día apareces primero en la lista de top jugadores de ese juego sabré porqué ha sido xD.

ya jugue Argentum muchos años, jugaba bastante bien, tenia clan torneos ganados y demas,actualmente juego gta v o elderscrolls online. Simplemente empece este proyecto para ver q podia lograr con mis conocimientos de programacion, aprender mas. y use este juego porque lo conozco y por lo q se la seguridad es basica, un buen lugar para empezar.
No pienso distribuir un cheat ni volverme top ranked ni mucho menos, programar divertirme y ver q puedo lograr , pero gracias por el consejo

La primera vez que veo ese juego, es online por lo que veo no? para todas las plataformas? Libre? Pero al ser online...nose pero no creo que te vayan a ayudar, eso creo que es delito el cheat para jugar en un juego online

Es un juego online, para windows y de codigo libre y gratuito. fue creado hace muchos años por un programador argentino y esta hecho en vb6( si bien existen versiones mas modernas pero incompletas desarrolladas en c/c++ y/o java).

No veo cual es el problema. los mismos tutoriales de blipi utilizan este juego como ejemplo.
Saludos,

Hola gente buenos dias, me presento.

Soy programador .net, trabajo con C# y tmb algo C/C++ y con X++(Axapta). Hace unos meses que estoy desarrollando un cheat de ArgentumOnline, orientado especialmente al servidor FuriusAO( www.furiusao.com.ar ). El cheat por el momento lee memoria y utiliza Sendinput y Mousehooks para llevar acabo tareas, como tomar pociones y demas. Pueden ver su funcionamiento en este video : www.youtube.com/watch?v=MkASgMdSfmk .

Me han ayudado mucho las guias de este foro, las he leido minuciosamente todas(Cheat Engine Basico,Avanzado, OllyDBG, WPEPRO, Sockets C#)

me encuentro en un punto de desarrollo que me esta costando mucho avanzar, puntualmente mudarme de la lectura de memoria y los inputs(furius ao parece haber incorporado un bloqueo de cualquier tipo de input por codigo) y moverme hacia el camino del sniffing o sino hookeo de funciones.

Realmente necesitaria entrar en contacto con alguien de este foro que pueda guiarme y ayudarme a sacar adelante este proyecto.

Saludos,
Raagh

queria comentarte que pude resolverlo, pones initial value uknown y te encuentra como 16m de valores(no aparecen mostrados porq son muchos pero fijate q dice arriba el numero).

y de ahi vas probando, perdes vida pones descreased value y buscas.
tomas una pota incresead value y buscas
asi unas cauntas veces y  se va reduciendo el valor hasta que te queden pocas. Son todas dinamicas obviamente. de ahi buscas un puntero asi tenes una estatica

Como referencia.La mayoria de los servers de AO no guardan directamente el valor de la vida, hacen algo medio raro. vos encontras una memoria que de valor dice 26542485.

auqnue no parezca ese numero es la vida. si vos dividis ese numero por 65537 te da un numero ese numero siempre coincide con tu vida( clarametne esto esta hecho para camuflar el valor)

dsp para encontrar el mana simplemente al puntero le aumentas +4 bits y encontras el mana(Es una struct con los valores).

Fijate si te sale cualquier cosa cometname q te ayudo

cree un thread tratando un tema parecido. a mi me pasa tmb eso con varios ao. Tierras de lobos imperium y otros mas. si me llegan a responder algo util con respecto a tu tema( en mi post pregunte tmb otras cosas) te aviso

saludos,

Mi post: http://foro.elhacker.net/ingenieria_inversa/ayuda_leer_memoriapacketes_hacking_argentum_onlinec-t429946.0.html

Hola gente buenos dias, soy nuevo en el foro y en el mundo del hacking concrectamente.

Hace poco decidi hacer por hobby algunos hacks para Argentum Online, un juego que jugaba mucho cuando era mas chico.

Arranque super basico con unos macros con sendkeys y leyendo pixeles de la pantalla para captar vida y mana y otras cosas por el estilo. Pero bueno llegue al punto que me gustaria leer memoria o packetes y llevar mis cheats al siguiente nivel.


Puntualmente creo q el primer paso seria, leer memoria(Vida y Mana) y en base a esas lecturas reaccionar y que se presione una tecla o algo por el estilo. Ese seria un paso menos radical desde donde estoy ahora.

Me mire los cursos de Blipi sobre hacking de juegos y consegui armarme un programa  que lea memoria y la escriba( PERO HECHO EN C# )  hackeando el HackMe que blipi nos dejo para su cheat de c++, anda perfecto.

pero el problema esta ahora aplicarlo a un caso real.

Estoy intentando leer la vida de un Argentum Online(Tierras de lobos AO, Imperium AO)
y en base a esa vida ejecutar una accion pero no encuentro la direccion.

Link: Tierras de lobos AO
https://mega.co.nz/#!AtoSBJYK!PKoo2v...xETw5nxcQZCVvQ

Link: Imperium Ao
http://www.imperiumao.com.ar/

Puntualmente me pasa lo mismo que a esta persona http://foro.elhacker.net/ingenieria_inversa/cheat_engine_ayuda_con_la_busqueda_de_un_address_valor-t427968.0.html


Si alguien puede ayudarme seria ideal. O me recomiendan que me saltee esto y pase directamente a leer paquetes y enviar paquetes ( leer vida/mana , enviar pociones). El tema con leer paquetes es q lo veo dificil desde c# y la verdad que mi idea es practicar este lenguaje y no volver a c/c++ ya que ahora trabajo como desarrolador .net

Les dejo el codigo del programa que hice para el HackMe 1.6 por si a alguien le sirve
Program:

Código [Seleccionar] Expandir


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace ReadMemory
{
   class Program
   {
       [DllImport("kernel32.dll")]
       public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);


       static void Main(string[] args)
       {
           Process process = Process.GetProcessesByName("HackMe_0.1.6")[0];
           IntPtr processHandle = OpenProcess(0x001F0FFF, false, process.Id);

           int structAddress = 0x00DA544C; // 0x00DA544C; Pointer to the struct that holds all values.

           int firstAddress = MemoryManagment.Read(processHandle, structAddress);
           int life = MemoryManagment.Read(processHandle, firstAddress + 0);
           int bullets = MemoryManagment.Read(processHandle, firstAddress + 4);
           int mana = MemoryManagment.Read(processHandle, firstAddress + 8);
           Console.WriteLine("----- Default Values -----");
           Console.WriteLine("Vida= " + life );
           Console.WriteLine("Balas= " + bullets);
           Console.WriteLine("Mana= " + mana);
           Console.WriteLine("----- Here it starts the Cheating -----");
           bool writingCompleted = false;
           while (MemoryManagment.IsProcessOpen("HackMe_0.1.6"))
           {
               writingCompleted = MemoryManagment.Write(processHandle, firstAddress + 0, 100);
               writingCompleted = MemoryManagment.Write(processHandle, firstAddress + 4, 10);
               writingCompleted = MemoryManagment.Write(processHandle, firstAddress + 8, 100);
           }
           Console.Clear();
           Console.WriteLine("Game Closed!,Cheating Completed!");
           Console.ReadKey();          
       }



   }
}

MemoryManagment:

Código [Seleccionar] Expandir


using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace ReadMemory
{
   public static class MemoryManagment
   {

       //Read DLL
       [DllImport("kernel32.dll", SetLastError = true)]
       public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer, int dwSize, out IntPtr lpNumberOfBytesRead);
       //Write DLL
       [DllImport("kernel32.dll")]
       static extern bool WriteProcessMemory(IntPtr hProcess,IntPtr lpBaseAddress,byte[] lpBuffer,int dwSize,out IntPtr lpNumberOfBytesWritten);


       public static bool IsProcessOpen(string name)
       {
           foreach (Process clsProcess in Process.GetProcesses())
           {
               if (clsProcess.ProcessName.Contains(name))
               {
                   return true;
               }
           }
           return false;
       }

       public static int Read(IntPtr handle, int address)
       {
           //1. Prepare buffer and pointer
           byte[] dataBuffer = new byte[4];
           IntPtr bytesRead = IntPtr.Zero;

           //2. Read
           ReadProcessMemory(handle, (IntPtr)address, dataBuffer, dataBuffer.Length, out bytesRead);

           //3. Error handling
           if (bytesRead == IntPtr.Zero)
           {
               Console.WriteLine("No se leyo nada!");
               Console.ReadKey();
               return 0;
           }
           if (bytesRead.ToInt32() < dataBuffer.Length)
           {
               Console.WriteLine("Se leyeron {0} de un total de {1} bytes!", bytesRead.ToInt32(), dataBuffer.Length.ToString());
               Console.ReadKey();
               return 0;
           }

           //4. Convert the content of your buffer to int
           return BitConverter.ToInt32(dataBuffer, 0);
       }

       //Writes the given int to memory and returns whether all (4) bytes were written or not
       public static bool Write(IntPtr handle, int address, int value)
       {
           //1. Create buffer and pointer
           byte[] dataBuffer = BitConverter.GetBytes(value);
           IntPtr bytesWritten = IntPtr.Zero;

           //2. Write
           WriteProcessMemory(handle, (IntPtr)address, dataBuffer, dataBuffer.Length, out bytesWritten);

           //3. Error handling
           if (bytesWritten == IntPtr.Zero)
           {
               Console.WriteLine("We didn't write anything!");
               return false;
           }
           if (bytesWritten.ToInt32() < dataBuffer.Length)
           {
               Console.WriteLine("We wrote {0} out of {1} bytes!", bytesWritten.ToInt32(), dataBuffer.Length.ToString());
               return false;
           }
           return true;
       }


   }
}