Gamerz Online

Finding Virtual Offsets

2011-09-09T07:23:00.001-07:00

Introduction

Finding virtual offsets provides us a way to access functions in the games that we otherwise would not be able access. Using either SDKCalls, Extensions, or MM:S Plugins, we can make use of these virtual offsets to give us a massive amount of functionality that is not included with Sourcemod out of the box.
For this example, you will need a copy of IDA Disassembler. We will be using IDA Pro 5.2 but any of the more recent versions should work fine (will not work with the free version). You will also need to grab this linux_vtable_dump.idc file and install it into your IDA/idc/ directory. Lastly, you will need to get a copy of the Linux server file for the game you want to find the offsets for. This will generally be in the 'bin' directory of your game folder and the file will be named server.so (use server_i486.so for older games that do not have server.so) along with some other similar files.

Finding Offsets

Disassemble the Linux Server:
Now that your files are setup appropriately, you can start the IDA Disassembler. On the Welcome to IDA box that opens initially, you will want to click the "New" button. This will allow us to add a new file for it to disassemble. After you initially disassemble the file, you will be able to reload it without any hassle by using the 'Previous' button and selecting the file on this screen.

After you click the New Button, the application will open. It will prompt you to choose a specific type of file from a box, however you can just close this as we do not need it. The screen should now say "Drag a File Here to disassemble". Open your folder containing the server_i486.so and drag drop this file in now. This will start the disassembling process, and depending on hardware, can take anywhere from 15-30 minutes to completely finish.

Find the Virtual Table::
You will want to be in IDA View-A and make sure you can see both the IDA View-A window as well as the Names window to make this easier on yourself. For this example, we will be finding the Virtual Offset for the function CBasePlayer::ChangeTeam. Our first step is to locate this function in the Names window. (The search hotkey combination is Alt+T) Now once you find this function, in the Names window, double click it, and it should select a line in the IDA View-A window that looks something similar to this.

From here we are going to want to go to the Jump Menu up top, and select Jump to Cross Reference. (The hotkey is CTRL+X) This will find the reference files for this paticular function. You will want to make sure that you find the line with `vtable at the start of it, as this will be the Virtual Table file that contains the offsets for us.

Save the Virtual Table file::
Now double click the line that says `vtable for'CBasePlayer and you will be brought back to the IDA View-A window. This time your cursor will be on the line with the VTable information. You have now successfully located the file you need, and you are ready to get the offsets. Making sure that your cursor is still somewhere in that line, go to...
File -> IDC File
and browse to the linux_vtable_dump.idc file that we placed in the IDA directory earlier. Load this file and click OK, and it will now ask you to enter a number for VTable's entries to ingore indexing. Setting this to 0 will output a file listing the exact Linux offsets, setting this to 1 will output a file which estimates the windows offsets (general rule is windows offset = linux offset - 1 but this isn't always the case). It will run your IDC script file, and give you another dialog box. This time it wants you to choose the location for the dump file. Browse to your desktop, and enter anything for the File Name box, and click Save. You now have a text file on your desktop will all of the CBaseEntity offsets inside of it that you can use.

Conclusion

That is all there is to it. Keep in mind that even though this is the Linux server file, the offsets listed in the dump file are for windows. You will just need to add +1 to these offsets to obtain the Linux offset. Make sure that you are using the Linux server file when you disassemble as well, because the Windows server does not have symbols or readable names, and you will not be able to find the offsets with it (unless you have the .pdb files for it, which only the Developers of the Game / Mod should have).

Windows Info

[07:38pm]  dvander word it in such a way that I can copy/paste it into the wiki
[07:38pm]  lol, i dunno if i can do that in IRC.  basically, there are two tricks
[07:39pm]  the first is if you know assembly really well
[07:39pm]  you can look at the SDK for a function that calls something you are interested in
[07:39pm]  find a string in that function, or a string in a function in its cross-reference graph
[07:40pm]  for the former case, find the same string in the windows binary and use the xref graph to find the right function
[07:40pm]  for the latter case, say a function with a string in it calls the function that has what you want
[07:40pm]  you find the first function, then read through it until you get to what you want
[07:41pm]  once you have the actual function you're looking for
[07:41pm]  you use the xref graph to find its reference in the data section
[07:41pm]  it will be in a large table - the virtual table
[07:41pm]  and you can compute its offset from the base of that table
[07:42pm]  the other trick is a bit easier, sometimes
[07:42pm]  you compile the SDK on windows
[07:42pm]  turn on the MSVC feature that dumps assembly
[07:42pm]  and poke around, using educated guessing

C++: Insertar un ejecutable dentro de otro… y luego ejecutarlo

2011-09-08T13:14:00.001-07:00

C++: Insertar un ejecutable dentro de otro… y luego ejecutarlo

Vamos a explicar cómo tomar un ejecutable (o cualquier otro fichero binario), insertarlo dentro de un ejecutable y posteriormente cómo recuperar ese ejecutable embebido, soltarlo a disco y ejecutarlo. El escenario típico es borrar el propio ejecutable que actúa como hospedante, pero seguro que a las mentes calenturientas de mis lectores se les ocurren más aplicaciones.
El problema no existía en Windows 95 y siguientes: un programa podía borrar su propio ejecutable y terminar sin ningún problema (o casi). Pero en los núcleos NT hacer eso es harina de otro costal. Teóricamente se puede hacer mientras que el ejecutable a borrar no abra ningún handle… pero evidentemente cualquier ejecutable suele abrir no uno, sino infinidad de ellos.
La solución consiste entonces en disponer de dos ejecutables en disco. El primero hará su tarea y llamará al segundo antes de terminar, que tras unos instantes procederá a borrar el primero, quedando éste último en disco. Pero entonces tenemos que distribuir dos ficheros y colocarlos en el mismo sitio, por lo que la mejor solución es que el primero contenga al segundo en sus entrañas y lo use a voluntad. Incidentalmente el segundo podría decir a Windows que lo borre en el siguiente reinicio, pero no vamos a entrar en detalles sobre esto.
Primer paso: Insertar el ejecutable
Suponiendo que tengamos ya construido nuestro ejecutable (que vamos a llamar “borra.exe”), insertar un recurso del tipo RCDATA en un fichero ejecutable es una tarea trivial. Basta con abrir el fichero de recursos del ejecutable (el .rc) como texto e insertar la línea:

ELEXE RCDATA "..\\final\\Win32\\Release\\borra.exe"

Recompilamos y ya tenemos el ejecutable como recurso binario embebido en nuestro propio ejecutable. Evidentemente no estamos limitados a ningún tipo de archivo en concreto. Podríamos hacerlo incluso con recursos normales (mapas de bits, iconos, cadenas, etc.). La única diferencia es la forma de recuperar un recurso binario de uno almacenado como estándar.
Segundo paso: Sacar el ejecutable y ponerlo en disco
Cuando queramos volcar nuestro ejecutable a disco, debemos ejecutar algo parecido a lo siguiente:

HRSRC res=FindResource(NULL,_T("ELEXE"),RT_RCDATA);
if(res==NULL)
     return GetLastError();

int size=SizeofResource(NULL,res);
HGLOBAL hRes=LoadResource(NULL,res);
unsigned char *pRes=(unsigned char *)LockResource(hRes);

HANDLE hFile=CreateFile(szT2Path,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,0,NULL);
if(hFile==INVALID_HANDLE_VALUE)
     return GetLastError();

WriteFile(hFile,pRes,size,&bytesWritten,NULL);
CloseHandle(hFile);

ShellExecute(HWND_DESKTOP,NULL,szT2Path,NULL,NULL,SW_SHOWNORMAL);

El primer paso consiste en llamar a FindResource con el nombre y el tipo de recurso. Si nuestro fichero hubiera estado almacenado en otro lugar que no fuera nuestro propio ejecutable, el primer parámetro a pasar es la instancia del fichero externo.
Tras tener un handle válido, tenemos que mirar el tamaño que ocupa el recurso almacenado, lo que hacemos con SizeofResource.
Ahora viene cargar el recurso en memoria y obtener un handle de memoria (LoadResource). Pero todavía no podemos acceder a los bytes de nuestro fichero, debemos bloquear el acceso a los mismos mediante LockResource, lo que nos devolverá un área de memoria accesible.
Aquí el autor lo ha asignado a un buffer de caracteres sin signo, pero realmente cualquier tipo de dato es perfectamente válido, aunque tenemos que tener en cuenta de no guardar ningún byte de más en el fichero final. Haciéndolo con un buffer de caracteres nos aseguramos de guardar el tamaño correcto.
Ya solo nos queda guardar el buffer a disco y hacer la llamada para ejecutar el fichero extraído.
Quizás nos preguntemos por qué no hemos liberado la memoria apuntada por pRes: está expresamente descrito en la documentación de la MSDN: no debemos hacerlo nosotros, ya lo hará el sistema cuando corresponda.
Consideraciones finales
Evidentemente una solución más sencilla sería marcar el propio ejecutable para ser borrado en el siguiente reinicio en lugar de hacer toda esta parafernalia, pero a veces puede no interesarnos que dicho fichero esté en disco hasta ese momento.
De todos modos aplicaciones para esto las hay a montones. Soltar un ejecutable que haga algo, termine y luego sea borrado por el programa principal, forzar un reinicio del programa principal, distribuir un solo exe que luego suelte todos los ficheros que necesite…

Origen: http://geeks.ms/blogs/rfog/archive/2008/09/11/c-insertar-un-ejecutable-dentro-de-otro-y-luego-ejecutarlo.aspx

Dota 2 Gamescom Trailer

2011-09-08T11:49:00.001-07:00

What does a hero truly need?

Find out when the world's best players compete in the first ever Dota2 professional tournament August 17th - 21st at Gamescom in Cologne, Germany. Watch live streaming games and replays at Dota2.com.

Visit Steam to download the 1080p HD version of the trailer.

TDL4: el virus indestructible

2011-08-18T12:52:00.000-07:00

TDL4, es el nombre del virus que hace a tu computadora formar parte de un botnet de más de 4.5 millones de máquinas. Cifra lograda en solo tres meses durante este año. Para los que no sepan con certeza, un botnet no es más que una red de computadoras infectadas que ejecutan, según las instrucciones del creador, pequeños programas que normalmente se utilizan para orquestar ataques DDoS (ataques de denegación de servicio) o enviar spam.
TDL4, llega a través del troyano llamado TDSS y, lo que lo hace tan especial, es que se instala fuera del sistema operativo, es decir, infecta directamente el disco duro, por esta razón, Kaspersky Labs dice que es prácticamente indestructible.

… se asegura que el código malicioso corra antes del sistema operativo… Tiene la habilidad de borrar otros programas maliciosos que no estén asociados con TDL, para evitar levantar sospechas. No todos, pero los más comunes.

Además, éste botnet tiene la habilidad de utilizar una red p2p pública, manteniendo sus servidores codificados y anónimos, lo que le suma poderío. Y como no sería un buen geek si no les asistiera con esto, les dejo algunos consejos.

¿Cómo saber si estoy infectado?

Uno de los métodos que más utiliza este virus para infectar, es disfrazarse de un falso códec de video.
Sus principales síntomas son:

Antivirus informando de un Virus en Svchost.
Errores en el inicio de Windows por la kdcom.dll
Navegadores web (IE, Firefox, Chrome) Secuestrados.
Blue-Screen al intentar ejecutar alguna herramienta de desinfección.
Instalación de sus malwares asociados: Oferbox, PriceGong, AutocompletePro
Problemas y errores varios a la hora de querer formatear o luego de.
Los resultados de las búsquedas de Google redireccionan a sitios nocivos.
Bloqueo al intentar ejecutar un Antivirus u otra herramientas de desinfección.
Detección constante de URL maliciosas por parte del Antivirus local que utilicemos.
Bloqueo del acceso a sitios webs relacionados a la seguridad informática.
Algunas herramientas de sistema de Windows están desactivadas. Administrador de Tareas, el Editor del Registro y otros.

Si no presentas ninguno de los síntomas, pero quieres asegurarte que tu computadora no trabaje de spammer o que sea parte de Ataques DDoS te recomiendo seguir los pasos para su eliminación.

Eliminar TDSS/ TDL4

Nos valdremos de dos herramientas gratuitas: TDSSKiller Antirootkit y MalwareBytes Antimalware (links proporcionados al final).
Lo único que tenemos que hacer es correr primero el análisis de TDSSKiller y aplicar Cure, de ser detectado algo. Posteriormente utilizaremos Antimalware para eliminar los archivos asociados.

Espero que les sea de utilidad.
Enlace: Descargar TDSSKiller
Enlace: Descargar Malwarebytes’ Anti-Malware

TDL4, el bot más sofisticado

2011-08-18T12:51:00.000-07:00

Las diferentes versiones de TDSS

El programa malicioso que Kaspersky Anti-Virus detecta como TDSS pertenece al grupo de los más complejos de hoy en día. TDSS usa diferentes trucos para evitar ser detectado por los métodos de firma, heurístico y proactivo; aplica métodos de cifrado durante la transmisión de datos entre el bot y el centro de administración y posee un potente componente rootkit que le permite camuflar la presencia de cualquier tipo de programas maliciosos en el sistema.
El nombre con que su autor bautizó el programa es TDL. Desde el momento de la aparición del programa malicioso en 2008, los creadores de virus lo han venido perfeccionando constantemente. En 2010 la última versión era TDL-3, cuya descripción detallada dimos en el artículo publicado en agosto de 2010.
Los autores de TDSS no pusieron el programa en venta sino hasta finales de 2010. En diciembre, al analizar uno de los especímenes, descubrimos algo extraño: el disco cifrado de TDL-3 contenía ciertos módulos de otro programa malicioso llamado SHIZ.

Contenido del disco cifrado de TDL-3 con los módulos del programa malicioso SHIZ

Entonces apareció en Internet el programa de afiliados que se dedicaba a suplantar los resultados de los sistemas de búsqueda y que pertenecía a los creadores de SHIZ, pero cuya estructura se basaba en TDL-3.
Los cambios introducidos en la configuración de TDL-3 y la aparición de un nuevo sistema de afiliados confirman que los códigos fuente de TDL-3 se vendieron a los delincuentes que antes se dedicaban al desarrollo del programa malicioso SHIZ.
Pero ¿por qué los autores de TDL decidieron vender los códigos fuente de la tercera versión? Es que para ese entonces ya había aparecido la versión TDL-4. Es probable que los cambios de esta versión les hayan parecido tan importantes a los escritores de virus que hayan dejado de temer la competencia por parte de los nuevos propietarios de TDL-3.
A finales de 2010 Viacheslav Rusakov describió el funcionamiento de la nueva versión del rootkit de TDSS desde el punto de vista de su interacción con el sistema operativo. En este artículo analizaremos TDL-4 desde el punto de vista de su funcionamiento con la red y la carga útil de la botnet que en el momento en que llevamos a cabo la investigación, contaba con más de 4,5 millones de ordenadores infectados.

De nuevo un programa de afiliados

En el funcionamiento de la nueva versión parece que quedó intacto sólo el método de propagación, por medio de los programas de afiliados. Como antes, para propagar el programa malicioso, los programas de afiliados siguen ofreciendo el descargador TDL que, después de constatar la versión del sistema operativo, descarga TDL-4 en el ordenador.

Programa de afiliados que propagan TDL

Por cada mil instalaciones, los afiliados a TDL reciben de 20 a 200 dólares americanos, dependiendo de la ubicación geográfica del equipo de la víctima. Los afiliados pueden usar cualquier método de instalación. Con más frecuencia TDL se difunde en los recursos pornográficos, los sitios piratas y los sitios de almacenamiento de vídeo y ficheros.
Los cambios en TDL-4 afectaron de alguna manera a casi todos los componentes del programa malicioso y sus actividades en la red. Los escritores de virus expandieron las funcionalidades del programa malicioso, modificaron el algoritmo de cifrado del protocolo de comunicación entre los bots y los servidores de administración de la botnet trataron de garantizarse el acceso a los equipos infectados incluso en caso de que se clausurasen los centros de administración de la botnet. Al parecer, los dueños de TDL están tratando de crear una botnet “indestructible”, protegida de las amenazas tanto de la competencia, como de las compañías antivirus.

La botnet “indestructible”

Cifrado de las conexiones de red

Uno de los cambios claves de TDL-4 en comparación con la versión anterior fue la actualización del algoritmo de cifrado del protocolo usado para la comunicación entre los equipos infectados y los servidores de administración de la botnet. Para reemplazar RC4, los delincuentes desarrollaron su propio algoritmo de cifrado, que usaba suplantaciones y operaciones XOR. Sirven de llaves de cifrado el nombre de dominio desde donde se inicia la conexión y el parámetro bsh del fichero cfg.ini.
Recordamos que la presencia de un fichero de configuración, donde se describen los principales parámetros usados por los diferentes módulos para llevar el registro de sus actividades y de la conexión con los servidores de administración es una de las peculiaridades de los programas maliciosos de la familia TDSS.

Ejemplo del contenido del fichero de configuración

En comparación con la tercera versión, el formato del fichero de configuración ha cambiado poco. La adición clave es el parámetro “bsh”. Este parámetro es el identificador del ejemplar del programa malicioso, asignado por el servidor de administración durante la primera conexión con el bot. También sirve como una de las llaves de cifrado durante las siguientes conexiones con el servidor de administración.

Parte del código (restaurado) de funcionamiento con el protocolo TDL-4

Durante la inicialización del protocolo se crea una tabla de suplantación para la solicitud http inicial del bot. Esta tabla se inicia con dos llaves: el nombre del dominio del servidor de administración de la botnet y el parámetro "bsh". La solicitud inicial se cifra y se convierte al formato base64. Después, en el inicio y final del mensaje obtenido, se agregan cadenas aleatorias escogidas con anterioridad en formato base64. La solicitud completa se envía al servidor mediante el protocolo HTTPS.
El algoritmo propio de cifrado de la comunicación entre los centros de administración de la botnet y la red evita que se pueda analizar el tráfico de red y bloquea los intentos de otros delincuentes de interceptar la administración de la botnet.

Un "antivirus” propio

TDL-4, al igual que Sinowal es un bootkit, es decir, para ejecutarse automáticamente infecta el sector MBR, lo que le permite iniciarse antes que el sistema operativo. Este método, usado por los virus de inicio clásicos, les garantiza a estos programas una gran vitalidad y los oculta de la mayoría de los programas de protección.
TDL es muy hábil para ocultarse a sí mismo y a los programas maliciosos y evitar que los antivirus los detecten. Para que los demás programas maliciosos que hayan penetrado al equipo sin la venia de los dueños de TDL no llamen la atención de los usuarios hacia el equipo infectado, TDL-4 tiene la posibilidad de eliminarlos. Por supuesto, no todos, sino los más populares.

Parte del código de TDSS que responde de la búsqueda de otros
programas maliciosos en el registro del sistema

TDSS tiene códigos para eliminar unos veinte programas maliciosos, incluyendo Gbot, ZeuS, Clishmic, Optima, etc. TDSS escanea el registro, busca nombres específicos de ficheros, pone en su lista negra las direcciones de los servidores de administración de otros botnets y bloquea el acceso a éstos desde el equipo infectado.
Por una parte, este “antivirus” ayuda a TDSS a luchar contra la competencia y por otra, a apartar de sí mismo y de su “equipo” (los programas maliciosos que instaló) los inconvenientes causados por la presencia en el ordenador infectado de otros programas maliciosos.
¿Qué programas maliciosos instala TDL-4? Desde principios de este año, en la botnet se han instalado cerca de 30 programas maliciosos adicionales, incluyendo falsos antivirus, módulos publicitarios y el spambot Pushdo.

Lista de descargas en la botnet TDSS

Es curioso que después de instalar otros programas maliciosos TDL-4 no se borra y puede usarse para desinstalar en cualquier momento sus programas maliciosos con la ayuda del módulo r.dll.

Acceso de la botnet a la red p2p Kad

Una de las innovaciones más brillantes de TDL-4 es el módulo kad.dll, que posibilita el acceso de la botnet TDSS a la red P2P Kad. Pero ¿por qué les hace falta a los delincuentes una red pública de intercambio de ficheros?
Hace bastante tiempo que se tiene noticias de botnets controladas mediante el protocolo P2P, pero hasta ahora se trataba de protocolos cerrados de comunicación creados por los delincuentes. TDSS, por su parte, usa una red P2P pública para enviar las instrucciones del dueño de la botnet a todos los ordenadores de la red zombi. El principio de funcionamiento del algoritmo de TDSS con esta red es el siguiente:

En la red pública Kad los delincuentes abren acceso a un fichero llamado ktzerules. El fichero está cifrado y contiene una lista de instrucciones para TDSS.
Los ordenadores infectados con TDSS reciben la instrucción de descargar e instalar el módulo kad.dll.
Una vez instalado, kad.dll descarga el fichero nodes.dat que contiene la lista pública de direcciones IP de los servidores y clientes de la red Kad.
En la red pública Kad el módulo kad.dll solicita la búsqueda del fichero ktzerules.
Después de descargar e instalar el fichero ktzerules, kad.dll ejecuta las instrucciones contenidas en ktzerules.

Actualizaciones cifradas del fichero kad.dll en la red pública Kad

Esta es la lista de instrucciones contenidas en el fichero cifrado ktzerules.

SearchCfg, buscar un nuevo fichero ktzerules en la red Kad
LoadExe, descargar y ejecutar el fichero ejecutable
ConfigWrite, escribir la entrada en cfg.ini
Search, buscar el fichero en la red Kad
Publish, publicar el fichero en la red Kad
Knock, descargar desde el centro de administración el fichero nodes.dat, que contiene la lista de direcciones IP de los servidores y clientes de la red Kad, entre ellos los ordenadores infectados por TDSS.

La instrucción más interesante es Knock. Mediante esta instrucción los delincuentes crean su propia red P2P Kad, cuyos clientes son sólo los ordenadores infectados por TDSS.

Esquema de intersección de la red pública y cerrada Kad

En esencia, en la administración de la botnet TDSS el módulo kad.dll cumple funciones análogas a cmd.dll. Usando el fichero nodes.dat, que contienen la lista de las direcciones IP de los participantes en la red Kad y ktzerules, que contiene la instrucción de descargar un nuevo fichero nodes.dat desde los servidores de los delincuentes, los dueños de la botnet pueden dar de alta o de baja los equipos infectados en la red pública Kad. En la red pública Kad no hay más de 10 ordenadores infectados por TDSS. Esto hace que sea muy difícil suplantar el fichero ktzerules y evita que otros delincuentes intercepten la administración de la botnet. En cambio, la cantidad general de ordenadores infectados con TDSS en la red cerrada es de varias decenas de miles.

Parte del código kad.dll que se encarga del transporte de las
instrucciones que los delincuentes envían mediante TDL-4

Además, el acceso a la red Kad les da a los delincuentes la posibilidad de descargar en los ordenadores de la botnet y hacer públicos para los usuarios de la red P2P cualquier tipo de ficheros, por ejemplo pornografía o bases de datos robadas.
La peligrosidad de esta botnet consiste en que, incluso si se cierran los centros de administración, los dueños de la misma no pierden el control sobre los ordenadores infectados. Sin embargo, este sistema tiene ciertas lagunas:

Usando la red pública Kad, los delincuentes corren el riesgo de que aparezcan instrucciones falsas para la botnet.
Durante el desarrollo del módulo kad.dll, para gestionar la interacción con la red Kad usaron códigos bajo licencia GPL GPL, lo que significa que los autores están infringiendo el acuerdo de licencia.

Expansión de las funcionalidades

Además de las funcionalidades publicitarias, en TDL-4 han aparecido nuevos módulos. Ya hemos escrito sobre el “antivirus” y el módulo de trabajo con redes P2P. Aparte de ellos, los dueños de TDSS incluyeron entre las funcionalidades del programa malicioso varios módulos más y ahora pueden ofrecer a sus clientes servicios de acceso anónimo a la red mediante los equipos infectados y soporte de sistemas de 64 bits.

Módulo del servidor proxy

Socks.dll es el nombre del fichero que TDSS incrusta en el proceso svchost y que sirve para abrir un servidor proxy en el equipo infectado. La presencia de este módulo permite navegar anónimamente en Internet mediante los equipos infectados.
Como cuentan con una gran cantidad de equipos con esta funcionalidad, los delincuentes han empezado a ofrecer servicios de conexión anónima a Internet. El coste del servicio es de unos 100 dólares al mes. Para ofrecer comodidad a sus usuarios, los delincuentes desarrollaron un plugin para Firefox que permite cambiar con rapidez los servidores proxy sin salir del navegador.

Plugin para Firefox que facilita la navegación en Internet
mediante los equipos infectados por TDSS

Soporte de sistemas de 64 bits

La aparición del driver de 64 bits en TDSS fue una de las novedades tecnológicas introducidas por los delincuentes en 2010. Para admitir el funcionamiento de los sistemas de 64 bits en régimen de usuario, TDL-4 contiene el módulo cmd64.dll, que es la versión de cmd.dll para sistemas de 64 bits. Sin embargo, debido a las limitaciones en el funcionamiento de los programas en sistemas de 64 bits, el código cmd64.dll contiene sólo las funcionalidades de comunicación con los servidores de administración de la botnet.

Lista de instrucciones enviadas por el servidor de administración de la botnet a TDSS

Trabajo con los sistemas de búsqueda

El módulo cmd.dll casi no ha sufrido cambios. Su tarea es establecer la conexión con los servidores de administración de la botnet y suplantar los resultados en los sistemas publicitarios y de búsqueda. En la lista de instrucciones para TDSS, la principal novedad es SetName, que asigna un número a cada ordenador infectado. Durante el trabajo con los sistemas de búsqueda y las redes de banners, TDSS usa la misma tecnología que otros programas maliciosos para hacer subir el rating de los resultados. Sin embargo, TDSS tiene la lista más larga de sistemas de búsqueda en los cuales suplanta los resultados de las búsquedas.

Lista de sistemas de búsqueda admitidos por TDSS

Servidores de administración de la botnet

TDSS usa varias fuentes para obtener las listas de administración de los servidores. Por defecto, la lista se toma del cuerpo de cmd.dll, pero si los servidores estuviesen fuera de alcance, el bot la toma de cfg.ini. Si por alguna razón ninguno de los servidores de administración de la lista cfg.ini está disponible, la lista se extrae del fichero cifrado bckfg.tmp, que el bot recibe la primera vez que se conecta al servidor de administración. Desde principios de este año se han registrado 60 servidores de administración de la botnet, distribuidos por todo el mundo.

Dirección del servidor de administración	Dirección del servidor a principios de febrero	Dirección del servidor a principios de marzo	Porcentaje de aparición en las listas de servidores de administración
01n02n4cx00.cc	noip	noip	0,05%
01n02n4cx00.com	91.212.226.5	noip	0,43%
01n20n4cx00.com	91.212.226.5	91.193.194.9	0,21%
0imh17agcla.com	77.79.13.28	91.207.192.22	0,80%
10n02n4cx00.com	194.28.113.20	194.28.113.20	0,22%
1il1il1il.com	91.212.158.72	91.212.158.72	6,89%
1l1i16b0.com	91.193.194.11	91.193.194.11	0,43%
34jh7alm94.asia	205.209.148.232	noip	0,03%
4gat16ag100.com	noip	noip	2,07%
4tag16ag100.com	178.17.164.129	91.216.122.250	6,69%
68b6b6b6.com	noip	noip	0,03%
69b69b6b96b.com	91.212.158.75	noip	6,89%
7gaur15eb71.com	195.234.124.66	195.234.124.66	6,85%
7uagr15eb71.com	noip	noip	2,07%
86b6b6b6.com	193.27.232.75	193.27.232.75	0,14%
86b6b96b.com	noip	noip	0,24%
9669b6b96b.com	193.27.232.75	193.27.232.75	0,22%
cap01tchaa.com	noip	noip	2,19%
cap0itchaa.com	noip	noip	0,58%
countri1l.com	91.212.226.6	91.212.158.72	6,89%
dg6a51ja813.com	91.216.122.250	93.114.40.221	6,85%
gd6a15ja813.com	91.212.226.5	91.212.226.5	2,07%
i0m71gmak01.com	noip	noip	0,80%
ikaturi11.com	91.212.158.75	noip	6,89%
jna0-0akq8x.com	77.79.13.28	77.79.13.28	0,80%
ka18i7gah10.com	93.114.40.221	93.114.40.221	6,85%
kai817hag10.com	noip	noip	2,07%
kangojim1.com	noip	noip	0,14%
kangojjm1.com	noip	noip	0,24%
kur1k0nona.com	68.168.212.21	68.168.212.21	2,19%
l04undreyk.com	noip	noip	0,58%
li1i16b0.com	noip	noip	0,05%
lj1i16b0.com	noip	noip	0,05%
lkaturi71.com	noip	noip	0,14%
lkaturl11.com	193.27.232.72	193.27.232.72	0,22%
lkaturl71.com	91.212.226.6	91.212.158.72	7,13%
lo4undreyk.com	68.168.212.18	93.114.40.221	2,19%
n16fa53.com	91.193.194.9	noip	0,05%
neywrika.in	noip	noip	0,14%
nichtadden.in	noip	noip	0,02%
nl6fa53.com	noip	noip	0,03%
nyewrika.in	noip	noip	0,03%
rukkeianno.com	noip	noip	0,08%
rukkeianno.in	noip	noip	0,08%
rukkieanno.in	noip	noip	0,03%
sh01cilewk.com	91.212.158.75	noip	2,19%
sho1cilewk.com	noip	noip	0,58%
u101mnay2k.com	noip	noip	2,19%
u101mnuy2k.com	noip	noip	0,58%
xx87lhfda88.com	91.193.194.8	noip	0,21%
zna61udha01.com	195.234.124.66	195.234.124.66	6,85%
zna81udha01.com	noip	noip	2,07%
zz87ihfda88.com	noip	noip	0,43%
zz87jhfda88.com	205.209.148.232	205.209.148.233	0,05%
zz87lhfda88.com	noip	noip	0,22%

Si se analiza con atención esta lista, se puede ver que las direcciones IP de los centros de administración cambian todo el tiempo y algunos dejan de funcionar. Estos cambios están condicionados por los servidores proxy que ocultan la verdadera ubicación de los centros de administración.

Estadística de los servidores de administración

A pesar de las medidas tomadas por los delincuentes para proteger los centros de administración de la botnet, conociendo el protocolo de comunicación de TDL-4 con los servidores de administración se pueden crear solicitudes especiales y recibir estadísticas de la cantidad de equipos infectados. Al analizar los datos obtenidos, se puso al descubierto tres bases de datos MySQL independientes ubicadas en Moldavia, Lituania y EEUU que admitían el funcionamiento de la botnet desde detrás de servidores proxy.
Según la información de estas bases de datos, sólo en el primer trimestre de 2011, TDL-4 infectó 4.524.488 equipos en todo el mundo.

Distribución por país de los equipos infectados por TDL-4

Casi una tercera parte de los equipos infectados se encuentra en los EE.UU. A juzgar por los precios de los programas de afiliados, infectar esta cantidad de equipos en EE.UU. cuesta 250.000 dólares, suma que al parecer gastaron los creadores de TDSS. Es curioso que en la estadística no figuran usuarios de Rusia. La explicación es que los programas de afiliados no ofrecen ningún pago por infectar usuarios rusos.

Esto todavía no es el final

El subtítulo de las últimas secciones de nuestros artículos sobre TDSS ya se está haciendo una tradición. En este caso tenemos razones para suponer que TDSS continuará desarrollándose. El activo perfeccionamiento del código de TDL-4, el rootkit para sistemas de 64 bits, el inicio antes del sistema operativo, el uso de exploits del arsenal de Stuxnet, el uso de la tecnología P2P, el antivirus propio y muchas cosas más ubican al programa malicioso TDSS entre los más desarrollados desde el punto de vista tecnológico y los más difíciles de analizar. Los delincuentes usan la botnet de más de 4.500.000 bots para manipular los sistemas publicitarios y los resultados de los sistemas de búsqueda, garantiza a los delincuentes acceso anónimo a Internet y sirve de plataforma para instalar otros programas maliciosos.
TDSS y la botnet que reúne los equipos infectados causarán muchos disgustos a los usuarios y los especialistas en seguridad IT. Una botnet descentralizada y sin servidores es prácticamente indestructible y la epidemia del gusano KIDO lo ha confirmado.

Pagina de Todos Los Audition

2011-08-07T16:16:00.001-07:00

Pagina de todos Los Audition del Mundo =)

(Indonesian) Audition : AyoDance - Dance Battle Game Online Indonesia - Indonesian Audition Website

(Chinese) http://au.9you.com - Chinese Audition Website

(Chinese) «l»R¹Î*»´äª©©x¤èºô¯¸ - Hong Kong Audition Website

(Korean) http://auditon.bugs.co.kr- Korean Audition Alt. Website (Bugs)

(English) 20% more Bana Cash from GoCash cards! - Audition North America Website

(English) Audition - Home - Philippines Audition Website

(Chinese) «l»R¹Î µØ¤H²Ä¤@*µ¼Ö¥æ¤Í ¥ð¶¢½u¤W¹CÀ¸ - Taiwanese Audition Website

(Thai) Audition Online Game ?? :PlayPark - Thai Audition Website

(English) AuditionSEA - Best Online Dancing Game in Singapore & Malaysia from Korea!- AuditionSEA Website

(Vietnamese) VTC Game : Audition - Mùa yêu th??ng- Vietnamese Audition Website

(Japanese) http://danpara.nexon.co.jp/ - Japanese Audition Website

(Koreano) http://reg.bugs.com.kr/ - Koreano

(koreano) http://clubaudition.ndolfin.com/SystemChk/Default.aspx- Koreano otro link

(koreano) http://audition.hanbiton.com/Home/SiteCheck.aspx - Koreano otro link

(Portugues) http://www.audition.com.br/ - Brasil

(Europa) http://audition.es.alaplaya.net/ - Europeo

El audition koreano tiene Problemas con su Pag...!! REvisen Continuo ..!!

Espero q les Sirva.
Creditos : Alaoz & -»HãdeSturk

How to find addies in WarRock

2011-08-07T16:14:00.001-07:00

I will just show you how to find addies in WarRock with "IDA Pro" and an "Unpacked WarRock (Latest one)", which can be downloaded in Google. If you don't know where to get it, go to the source code section and their should be one.

Firstoff, open IDA Pro and Click File -> Open and search for the unpacked WarRock (or Dumped /).

Now we are ready to find the addies.

PlayerPointer:
-Search for "DX01" and go up twice or three times.

So it's dword_A547A0. Just take out "dword_" and add 0x00 to it [Prefix].
It should be like this in C++: #define Addr_PlayerPointer 0x00A547A0

ServerPointer:
-Same processus, but you got to search for "CF01" now and go up three times.

It's dword_94F7C0.

So, it's gonna be this in C++: #define Addr_ServerPointer 0x0094F7C0

FastAmmo:

Search for "ammo_base".
[php]___:0042B2A6 mov eax, [esi+8]
___:0042B2A9 cmp dword ptr [eax+18h], 0
___:0042B2AD jnz loc_42B368
___:0042B2B3 mov eax, [eax+1Ch]
___:0042B2B6 mov eax, [eax+0E8h]
___:0042B2BC add eax, 8
___:0042B2BF push offset aAmmo_base ; "ammo_base"
___:0042B2C4 push eax
___:0042B2C5 call sub_68DAED
___:0042B2CA test eax, eax
___:0042B2CC pop ecx
___:0042B2CD pop ecx
___:0042B2CE jnz short loc_42B316
___:0042B2D0 fld [ebp+var_4]
___:0042B2D3 fcomp flt_76BE84
___:0042B2D9 fnstsw ax
___:0042B2DB test ah, 5
___:0042B2DE jp loc_42B368
___:0042B2E4 cmp dword_7BFE10, 1Bh
___:0042B2EB jz short loc_42B30A
___:0042B2ED fld flt_89B048
___:0042B2F3 lea eax, [ebp+var_10]
___:0042B2F6 fmul flt_7615C0
___:0042B2FC push eax
___:0042B2FD mov ecx, offset dword_89E53C <--- FastAmmo
___:0042B302 fstp [ebp+var_10]
___:0042B305 call sub_42A28A[/php]

So, it's 89E53C. In C++: #define Addr_FastAmmo 0x0089E53C

FastRepair:
Search for "repair_base".
[php]___:0042B316 mov eax, [esi+8]
___:0042B319 mov eax, [eax+1Ch]
___:0042B31C mov eax, [eax+0E8h]
___:0042B322 add eax, 8
___:0042B325 push offset aRepair_base ; "repair_base"
___:0042B32A push eax
___:0042B32B call sub_68DAED
___:0042B330 test eax, eax
___:0042B332 pop ecx
___:0042B333 pop ecx
___:0042B334 jnz short loc_42B368
___:0042B336 fld [ebp+var_14]
___:0042B339 fcomp flt_76BE84
___:0042B33F fnstsw ax
___:0042B341 test ah, 5
___:0042B344 jp short loc_42B368
___:0042B346 cmp dword_7BFE14, 1Bh
___:0042B34D jz short loc_42B35E
___:0042B34F push offset flt_89B048
___:0042B354 mov ecx, offset dword_89E540
___:0042B359 call sub_42A28A[/php]
So, it's 89E540. In C++: #define Addr_FastRepair 0x0089E540

More to be add...

Creditz: 100% MINE so don't leech you nub

Bye Bye!

How to find addys? - In Depth tutorial

2011-08-07T16:13:00.000-07:00

Hello,
pagn released some tuts of this in the past:
Sticky: How to find addies in WarRock

Im going to give a tutorial of in depth of addys finding, TheCamels8 probably can do a better job in this case.

By reading this you accept the rules of mpgh, you do not spam this thread, no outside links etc.

You will need:1. Dumped 'WarRock.exe' -> Tutorial here
2. Ida Pro

First we are going to look for 'MapCollor1,MapCollor2,MapCollor3'Open Ida pro -> Search -> Text -> "Light.Ambient"

Once you have found it, go up untill you see "Light.GlobalAmbient"
Then we have to find our addies, look for the "push"
Then we will get this addies: (Those are from the current update)

Code:

___:004C9471                 push    offset flt_A4ADE0
___:004C9476                 push    offset flt_A4ADDC
___:004C947B                 push    offset flt_A4ADD8

FullBright

Scroll down until you see: "Light.Ambient"
Look again for the "push"
You will get the following code:

Code:

___:004C949C                 push    offset flt_A4ADB0
___:004C94A1                 push    offset flt_A4ADAC
___:004C94A6                 push    offset flt_A4ADA8

GlassWalls

Scroll down until you see "Frustum.FarDistance"
Look again for the "Push"
This line is our adress:

Code:

___:004C956E                 push    offset flt_A4AD48

Near Fog
Scroll down untill you see "Fog.NearDistance"
Look again for the "Push"
You will get this line:

Code:

___:004C958F                 push    offset dword_A4AE48

Code:

http://img27.imageshack.us/img27/9652/part6s.jpg

Far Fog

Scrol down untill you see "Fog.FarDistance"
You will need to look again for the "Push"
This will be our addy:

Code:

___:004C95F0                 push    offset dword_A4AE4C

Fog Collor
Scroll down until you see "Fog.Color"
Look for the 3 "Push"
This will be our addy:

Code:

___:004C966D                 push    offset flt_A4ADF8
___:004C9672                 push    offset flt_A4ADF4
___:004C9677                 push    offset flt_A4ADF0

I know it is not so much, it is done before & all that
But its just to help some of you out, if you need help,feel free to ask me

Credits:
TheCamels8
AeroMan

[Tutorial] Come Here to Learn How to Dumped Warrock

2011-08-07T16:12:00.001-07:00

Hey guys This Tut Made by me it show u how u can dumped warrock
Some PPl GonA Ask me " What do it need with that dumped " Simple U Can Find warrock Addy with IT and i gona Teach u ho on the Next Tut.

Lets Start :

First Download This : I Will upload the file later cuz my net is Slow

1_Now After u Download It Run Kernel Detective
2_Open Warrock And Dont Log In With Ur Id + Pw
3_Do Like this

4_ Add Name Here And Dont Forget .exe

Now We Done Wait Until i will Post New Topic About How to Find Addys

Cerdits :
Me

[Source Code] Weapon Sources

2011-08-07T16:11:00.001-07:00

All credits to me
Old Weapon List:

__:00AE3DB0 dd offset aKnife_1st ; "knife_1st"
___:00AE3DB4 dd offset aFknife_1st ; "Fknife_1st"
___:00AE3DB8 dd offset off_99B518
___:00AE3DBC dd offset aSwd_cover ; "swd_cover"
___:00AE3DC0 dd offset aThammer1st ; "thammer1st"
___:00AE3DC4 dd offset aFknife_1st ; "Fknife_1st"
___:00AE3DC8 dd offset off_99B518
___:00AE3DCC dd offset aSwd_cover ; "swd_cover"
___:00AE3DD0 dd offset aColt_body ; "Colt_body"
___:00AE3DD4 dd offset aColt_mag ; "Colt_mag"
___:00AE3DD8 dd offset aColt_reload ; "Colt_reload"
___:00AE3DDC dd offset aColt_trigger ; "Colt_trigger"
___:00AE3DE0 dd offset aColt_trigger02 ; "Colt_trigger02"
___:00AE3DE4 dd offset aDer_body ; "der_body"
___:00AE3DE8 dd offset aDer_mag ; "der_mag"
___:00AE3DEC dd offset aDer_reload ; "der_reload"
___:00AE3DF0 dd offset aDer_trigger ; "der_trigger"
___:00AE3DF4 dd offset aMp5ka_body ; "MP5ka_body"
___:00AE3DF8 dd offset aMp5ka_mag ; "MP5ka_mag"
___:00AE3DFC dd offset aMp5ka_reload ; "MP5ka_reload"
___:00AE3E00 dd offset aMp5ka_trigger ; "MP5ka_trigger"
___:00AE3E04 dd offset aRevolver_body ; "revolver_body"
___:00AE3E08 dd offset aRevolver_bul_4 ; "revolver_bullet01"
___:00AE3E0C dd offset aRevolver_bul_3 ; "revolver_bullet02"
___:00AE3E10 dd offset aRevolver_bul_2 ; "revolver_bullet03"
___:00AE3E14 dd offset aRevolver_bul_1 ; "revolver_bullet04"
___:00AE3E18 dd offset aRevolver_bul_0 ; "revolver_bullet05"
___:00AE3E1C dd offset aRevolver_bulle ; "revolver_bullet06"
___:00AE3E20 dd offset aRevolver_newbu ; "revolver_newbullet"
___:00AE3E24 dd offset aRevolver_rel_0 ; "revolver_reload01"
___:00AE3E28 dd offset aRevolver_reloa ; "revolver_reload02"
___:00AE3E2C dd offset aRevolver_sploa ; "revolver_sploader"
___:00AE3E30 dd offset aRevolver_trige ; "revolver_triger"
___:00AE3E34 dd offset aGlock_body ; "glock_body"
___:00AE3E38 dd offset aGlock_mag ; "glock_mag"
___:00AE3E3C dd offset aGlock_reloader ; "glock_reloader"
___:00AE3E40 dd offset aGlock_tigger ; "glock_tigger"
___:00AE3E44 dd offset aBeretta1st_l_b ; "beretta1st_L_body"
___:00AE3E48 dd offset aBeretta1st_l_m ; "beretta1st_L_mag"
___:00AE3E4C dd offset aBeretta1st_l_r ; "beretta1st_L_reload"
___:00AE3E50 dd offset aBeretta1st_r_b ; "beretta1st_R_body"
___:00AE3E54 dd offset aBeretta1st_r_m ; "beretta1st_R_mag"
___:00AE3E58 dd offset aBeretta1st_r_r ; "beretta1st_R_reload"
___:00AE3E5C dd offset aThrowknife1s_0 ; "throwknife1st_L"
___:00AE3E60 dd offset aThrowknife1st_ ; "throwknife1st_R"
___:00AE3E64 dd offset aMuzi_mag ; "muzi_mag"
___:00AE3E68 dd offset aMuzi_reload ; "muzi_reload"
___:00AE3E6C dd offset aMuzi_body ; "muzi_body"
___:00AE3E70 dd offset aBeretta92_body ; "beretta92_body"
___:00AE3E74 dd offset aBeretta92_hamm ; "beretta92_hammer"
___:00AE3E78 dd offset aBeretta92_mag ; "beretta92_mag"
___:00AE3E7C dd offset aBeretta92_slid ; "beretta92_slide"
___:00AE3E80 dd offset aMp5ka_reload ; "MP5ka_reload"
___:00AE3E84 dd offset aMp5ka_trigger ; "MP5ka_trigger"
___:00AE3E88 dd offset aMp5ka_mag_gold ; "MP5ka_mag_gold"
___:00AE3E8C dd offset aMp5ka_body_gol ; "MP5ka_body_gold"
___:00AE3E90 dd offset aMp5ka_mag ; "MP5ka_mag"
___:00AE3E94 dd offset aMp5ka_reload ; "MP5ka_reload"
___:00AE3E98 dd offset aMp5ka_trigger ; "MP5ka_trigger"
___:00AE3E9C dd offset aMp5ka_body_sco ; "MP5ka_body_scop"
___:00AE3EA0 dd offset aAk_ac ; "AK_ac"
___:00AE3EA4 dd offset aAk_body ; "AK_body"
___:00AE3EA8 dd offset aAk_mag ; "AK_mag"
___:00AE3EAC dd offset aAk_reload ; "AK_reload"
___:00AE3EB0 dd offset aK2_acc ; "k2_acc"
___:00AE3EB4 dd offset aK2_body ; "k2_body"
___:00AE3EB8 dd offset aK2_mag ; "k2_mag"
___:00AE3EBC dd offset aK2_reload ; "k2_reload"
___:00AE3EC0 dd offset aM4_body ; "M4_Body"
___:00AE3EC4 dd offset aM4_mag ; "M4_mag"
___:00AE3EC8 dd offset aM4_reload_pu_0 ; "M4_reload_pull"
___:00AE3ECC dd offset aFamas_body ; "famas_body"
___:00AE3ED0 dd offset aFamas_mag ; "famas_mag"
___:00AE3ED4 dd offset aFamas_reload ; "famas_reload"
___:00AE3ED8 dd offset aFamas_trigger ; "famas_trigger"
___:00AE3EDC dd offset aL85a1_body ; "L85A1_body"
___:00AE3EE0 dd offset aL85a1_reload ; "L85A1_reload"
___:00AE3EE4 dd offset aXm8_body ; "XM8_Body"
___:00AE3EE8 dd offset aXm8_mag ; "XM8_mag"
___:00AE3EEC dd offset aXm8_reload ; "XM8_reload"
___:00AE3EF0 dd offset aXm8_reload_in ; "XM8_reload_in"
___:00AE3EF4 dd offset aJ89t_body ; "J89T_body"
___:00AE3EF8 dd offset aJ89t_mag ; "J89T_mag"
___:00AE3EFC dd offset aJ89t_reload ; "J89T_reload"
___:00AE3F00 dd offset aSig550_body ; "SIG550_body"
___:00AE3F04 dd offset aSig550_mag ; "SIG550_mag"
___:00AE3F08 dd offset aSig550_reload ; "SIG550_reload"
___:00AE3F0C dd offset aTar21_body ; "tar21_body"
___:00AE3F10 dd offset aTar21_reload ; "tar21_reload"
___:00AE3F14 dd offset aM16a4 ; "M16A4"
___:00AE3F18 dd offset aM16a4_mag ; "M16A4_mag"
___:00AE3F1C dd offset aAn94_mag ; "an94_mag"
___:00AE3F20 dd offset aAn94_reload ; "an94_reload"
___:00AE3F24 dd offset aAn94_cyl ; "an94_cyl"
___:00AE3F28 dd offset aAn94_body ; "an94_body"
___:00AE3F2C dd offset aM16a4_silver_m ; "M16A4_silver_mag"
___:00AE3F30 dd offset aM16a4_silver ; "M16A4_silver"
___:00AE3F34 dd offset aAk_mag ; "AK_mag"
___:00AE3F38 dd offset aAk_reload ; "AK_reload"
___:00AE3F3C dd offset aAk_body_scope ; "AK_body_scope"
___:00AE3F40 dd offset aAk_ac ; "AK_ac"
___:00AE3F44 dd offset aM4_mag_gold ; "M4_mag_gold"
___:00AE3F48 dd offset aM4_reload_pull ; "M4_reload_pull_gold"
___:00AE3F4C dd offset aM4_body_gold ; "M4_Body_gold"
___:00AE3F50 dd offset aG36_mag ; "G36_mag"
___:00AE3F54 dd offset aG36_reload ; "G36_reload"
___:00AE3F58 dd offset aG36_reload_in ; "G36_reload_in"
___:00AE3F5C dd offset aG36c ; "G36C"
___:00AE3F60 dd offset aG36_100 ; "G36_100"
___:00AE3F64 dd offset aG36_reload ; "G36_reload"
___:00AE3F68 dd offset aG36_reload_in ; "G36_reload_in"
___:00AE3F6C dd offset aG36c ; "G36C"
___:00AE3F70 dd offset aAks74u_mag ; "AKS74U_mag"
___:00AE3F74 dd offset aAks74u_reload ; "AKS74U_reload"
___:00AE3F78 dd offset aAks74u_0 ; "AKS74U"
___:00AE3F7C dd offset aG36 ; "G36"
___:00AE3F80 dd offset aG36_mag ; "G36_mag"
___:00AE3F84 dd offset aG36_reload ; "G36_reload"
___:00AE3F88 dd offset aG36_reload_in ; "G36_reload_in"
___:00AE3F8C dd offset aG36 ; "G36"
___:00AE3F90 dd offset aG36_100 ; "G36_100"
___:00AE3F94 dd offset aG36_reload ; "G36_reload"
___:00AE3F98 dd offset aG36_reload_in ; "G36_reload_in"
___:00AE3F9C dd offset aHkmp5_body ; "HKmp5_body"
___:00AE3FA0 dd offset aHkmp5_mag ; "HKmp5_mag"
___:00AE3FA4 dd offset aHkmp5_reload ; "HKmp5_reload"
___:00AE3FA8 dd offset aHkmp5_trigger ; "HKmp5_trigger"
___:00AE3FAC dd offset aP90_body ; "P90_body"
___:00AE3FB0 dd offset aP90_mag ; "P90_mag"
___:00AE3FB4 dd offset aP90_reload ; "P90_reload"
___:00AE3FB8 dd offset aP90_trigger ; "P90_trigger"
___:00AE3FBC dd offset aUzi_acc ; "UZI_acc"
___:00AE3FC0 dd offset aUzi_body ; "UZI_body"
___:00AE3FC4 dd offset aUzi_mag ; "UZI_mag"
___:00AE3FC8 dd offset aUzi_reload ; "UZI_reload"
___:00AE3FCC dd offset aTmp9 ; "TMP9"
___:00AE3FD0 dd offset aTmp9_mag ; "TMP9_mag"
___:00AE3FD4 dd offset aTmp9_reload ; "TMP9_reload"
___:00AE3FD8 dd offset aK1_0 ; "k1"
___:00AE3FDC dd offset aK1_acc_b01 ; "k1_acc_B01"
___:00AE3FE0 dd offset aK1_acc_b02 ; "k1_acc_B02"
___:00AE3FE4 dd offset aK1_acc_f ; "k1_acc_F"
___:00AE3FE8 dd offset aK1_mag ; "k1_mag"
___:00AE3FEC dd offset aK1_reload ; "k1_reload"
___:00AE3FF0 dd offset aMp7_1st_body ; "mp7_1st_body"
___:00AE3FF4 dd offset aMp7_1st_hand ; "mp7_1st_hand"
___:00AE3FF8 dd offset aMp7_1st_mag ; "mp7_1st_mag"
___:00AE3FFC dd offset aMp7_1st_reload ; "mp7_1st_reload"
___:00AE4000 dd offset aScpn_body_l ; "scpn_body_L"
___:00AE4004 dd offset aScpn_body_r ; "scpn_body_R"
___:00AE4008 dd offset aScpn_mag_l ; "scpn_mag_L"
___:00AE400C dd offset aScpn_mag_r ; "scpn_mag_R"
___:00AE4010 dd offset aScpn_reload_l ; "scpn_reload_L"
___:00AE4014 dd offset aScpn_reload_r ; "scpn_reload_R"
___:00AE4018 dd offset aSpectre_body ; "spectre_body"
___:00AE401C dd offset aSpectre_mag ; "spectre_mag"
___:00AE4020 dd offset aSpectre_reload ; "spectre_reload"
___:00AE4024 dd offset aMac10_body ; "MAC10_body"
___:00AE4028 dd offset aMac10_hand01 ; "MAC10_hand01"
___:00AE402C dd offset aMac10_hand02 ; "MAC10_hand02"
___:00AE4030 dd offset aMac10_hand03 ; "MAC10_hand03"
___:00AE4034 dd offset aMac10_mag ; "MAC10_mag"
___:00AE4038 dd offset aMac10_reload ; "MAC10_reload"
___:00AE403C dd offset aUmp45_body ; "ump45_body"
___:00AE4040 dd offset aUmp45_laser ; "ump45_laser"
___:00AE4044 dd offset aUmp45_mag ; "ump45_mag"
___:00AE4048 dd offset aUmp45_reload ; "ump45_reload"
___:00AE404C dd offset aCx4_body ; "cx4_body"
___:00AE4050 dd offset aCx4_mag ; "cx4_mag"
___:00AE4054 dd offset aCx4_reload ; "cx4_reload"
___:00AE4058 dd offset aP90_silver_mag ; "P90_silver_mag"
___:00AE405C dd offset aP90_silver_tri ; "P90_silver_trigger"
___:00AE4060 dd offset aP90_silver_rel ; "P90_silver_reload"
___:00AE4064 dd offset aP90_silver_bod ; "P90_silver_body"
___:00AE4068 dd offset aK1_acc_b02_gol ; "k1_acc_B02_gold"
___:00AE406C dd offset aK1_acc_b01_gol ; "k1_acc_B01_gold"
___:00AE4070 dd offset aK1_acc_f_gold ; "k1_acc_F_gold"
___:00AE4074 dd offset aK1_mag_gold ; "k1_mag_gold"
___:00AE4078 dd offset aK1_gold_0 ; "k1_gold"
___:00AE407C dd offset aK1_reload ; "k1_reload"
___:00AE4080 dd offset aCx4_mag ; "cx4_mag"
___:00AE4084 dd offset aCx4_reload ; "cx4_reload"
___:00AE4088 dd offset aCx4_digital_bo ; "cx4_digital_body"
___:00AE408C dd offset aPsg_body ; "Psg_body"
___:00AE4090 dd offset aPsg_mag ; "Psg_mag"
___:00AE4094 dd offset aPsg_reload ; "Psg_reload"
___:00AE4098 dd offset aM82 ; "m82"
___:00AE409C dd offset aM82_mag ; "m82_mag"
___:00AE40A0 dd offset aM82_reload ; "m82_reload"
___:00AE40A4 dd offset aAug_body ; "aug_body"
___:00AE40A8 dd offset aAug_reload ; "aug_reload"
___:00AE40AC dd offset aSsg69_body ; "SSG69_body"
___:00AE40B0 dd offset aSsg69_mag ; "SSG69_mag"
___:00AE40B4 dd offset aSsg69_reload01 ; "SSG69_reload01"
___:00AE40B8 dd offset aSsg69_reload02 ; "SSG69_reload02"
___:00AE40BC dd offset aM24_body ; "M24_body"
___:00AE40C0 dd offset aM24_mag ; "M24_mag"
___:00AE40C4 dd offset aM24_reload01 ; "M24_reload01"
___:00AE40C8 dd offset aM24_reload02 ; "M24_reload02"
___:00AE40CC dd offset aDragunov_reloa ; "dragunov_reload"
___:00AE40D0 dd offset aDragunov_mag ; "dragunov_mag"
___:00AE40D4 dd offset aDragunov_body ; "dragunov_body"
___:00AE40D8 dd offset aAwm_body ; "AWM_body"
___:00AE40DC dd offset aAwm_mag ; "AWM_mag"
___:00AE40E0 dd offset aAwm_reload01 ; "AWM_reload01"
___:00AE40E4 dd offset aAwm_reload02 ; "AWM_reload02"
___:00AE40E8 dd offset aAw50f_body ; "AW50f_body"
___:00AE40EC dd offset aAw50f_mag ; "AW50f_mag"
___:00AE40F0 dd offset aAw50f_reload01 ; "AW50f_reload01"
___:00AE40F4 dd offset aAw50f_reload02 ; "AW50f_reload02"
___:00AE40F8 dd offset aM21_mag ; "m21_mag"
___:00AE40FC dd offset aM21_reload ; "m21_reload"
___:00AE4100 dd offset aM21_body ; "m21_body"
___:00AE4104 dd offset aWa2000_reload ; "wa2000_reload"
___:00AE4108 dd offset aWa2000_body ; "wa2000_body"
___:00AE410C dd offset aM40a1_bullet ; "m40a1_bullet"
___:00AE4110 dd offset aM40a1_reload ; "m40a1_reload"
___:00AE4114 dd offset aM40a1_body ; "m40a1_body"
___:00AE4118 dd offset aAwm_reload01_g ; "AWM_reload01_gold"
___:00AE411C dd offset aAwm_reload02_g ; "AWM_reload02_gold"
___:00AE4120 dd offset aAwm_mag_gold ; "AWM_mag_gold"
___:00AE4124 dd offset aAwm_body_gold ; "AWM_body_gold"
___:00AE4128 dd offset aPsg_mag ; "Psg_mag"
___:00AE412C dd offset aPsg_reload ; "Psg_reload"
___:00AE4130 dd offset aPsg_body_red ; "Psg_body_red"
___:00AE4134 dd offset aSsg69_mag ; "SSG69_mag"
___:00AE4138 dd offset aSsg69_silver_0 ; "SSG69_silver_reload02"
___:00AE413C dd offset aSsg69_silver_r ; "SSG69_silver_reload01"
___:00AE4140 dd offset aSsg69_silver_b ; "SSG69_silver_body"
___:00AE4144 dd offset aM60_body ; "m60_body"
___:00AE4148 dd offset aM60_box ; "m60_box"
___:00AE414C dd offset aM60_bullet01 ; "m60_bullet01"
___:00AE4150 dd offset aM60_bullet02 ; "m60_bullet02"
___:00AE4154 dd offset aM60_bullet03 ; "m60_bullet03"
___:00AE4158 dd offset aM60_cap ; "m60_cap"
___:00AE415C dd offset aM60_leg ; "m60_leg"
___:00AE4160 dd offset aM249_body ; "m249_body"
___:00AE4164 dd offset aM249_bullet01 ; "m249_bullet01"
___:00AE4168 dd offset aM249_bullet02 ; "m249_bullet02"
___:00AE416C dd offset aM249_bullet03 ; "m249_bullet03"
___:00AE4170 dd offset aM249_mag ; "m249_mag"
___:00AE4174 dd offset aM249_open ; "m249_open"
___:00AE4178 dd offset aM249_trigger ; "m249_trigger"
___:00AE417C dd offset aSg_winch_body ; "SG_winch_body"
___:00AE4180 dd offset aSg_winch_reloa ; "SG_winch_reload"
___:00AE4184 dd offset aSg_winch_shell ; "SG_winch_shell"
___:00AE4188 dd offset aSg_winch_trigg ; "SG_winch_trigger"
___:00AE418C dd offset aSg_winch_shell ; "SG_winch_shell"
___:00AE4190 dd offset aM4super90_1st ; "m4super90_1st"
___:00AE4194 dd offset aPanzer_body_0 ; "Panzer_body"
___:00AE4198 dd offset aPanzer_mis ; "Panzer_mis"
___:00AE419C dd offset aRpg7_0 ; "rpg7"
___:00AE41A0 dd offset aRpg7rok ; "rpg7rok"
___:00AE41A4 dd offset aJavelin_1st ; "javelin_1st"
___:00AE41A8 dd offset aJavelin_1st_cy ; "javelin_1st_cyl"
___:00AE41AC dd offset aRpg7rok ; "rpg7rok"
___:00AE41B0 dd offset aRpg7_gold ; "rpg7_gold"
___:00AE41B4 dd offset aRpg7night_rok ; "rpg7night_rok"
___:00AE41B8 dd offset aRpg7night ; "rpg7night"
___:00AE41BC dd offset aStinger_1st ; "Stinger_1st"
___:00AE41C0 dd offset aStinger_miss ; "stinger_miss"
___:00AE41C4 dd offset aMine_1st ; "Mine_1st"
___:00AE41C8 dd offset aGra_body ; "Gra_Body"
___:00AE41CC dd offset aGra_clip ; "Gra_clip"
___:00AE41D0 dd offset aGra_pin01 ; "Gra_pin01"
___:00AE41D4 dd offset aGra_pin02 ; "Gra_pin02"
___:00AE41D8 dd offset aGra_body ; "Gra_Body"
___:00AE41DC dd offset aGra_clip ; "Gra_clip"
___:00AE41E0 dd offset aGra_pin01 ; "Gra_pin01"
___:00AE41E4 dd offset aGra_pin02 ; "Gra_pin02"
___:00AE41E8 dd offset aGra_pin01 ; "Gra_pin01"
___:00AE41EC dd offset aGra_pin02 ; "Gra_pin02"
___:00AE41F0 dd offset aSmoke_gra ; "smoke_gra"
___:00AE41F4 dd offset aFlash_gra ; "flash_gra"
___:00AE41F8 dd offset aGra_pin01 ; "Gra_pin01"
___:00AE41FC dd offset aGra_pin02 ; "Gra_pin02"
___:00AE4200 dd offset aFlash_gra ; "flash_gra"
___:00AE4204 dd offset aGra_pin01 ; "Gra_pin01"
___:00AE4208 dd offset aGra_pin02 ; "Gra_pin02"
___:00AE420C dd offset aRb_clamoa ; "RB_clamoa"
___:00AE4210 dd offset aRb_clamoa_bt_0 ; "RB_clamoa_btn01"
___:00AE4214 dd offset aRb_clamoa_btn0 ; "RB_clamoa_btn02"
___:00AE4218 dd offset aPda_1st ; "pda_1st"
___:00AE421C dd offset aPda_1st ; "pda_1st"
___:00AE4220 dd offset aPda_light ; "pda_light"
___:00AE4224 dd offset aPda_light_02 ; "pda_light_02"
___:00AE4228 dd offset aC4 ; "C4"
___:00AE422C dd offset aC4_text05 ; "C4_text05"
___:00AE4230 dd offset aC4_text01 ; "C4_text01"
___:00AE4234 dd offset aC4_text06 ; "C4_text06"
___:00AE4238 dd offset aC4_text03 ; "C4_text03"
___:00AE423C dd offset aC4_text07 ; "C4_text07"
___:00AE4240 dd offset aC4_text04 ; "C4_text04"
___:00AE4244 dd offset aC4_text02 ; "C4_text02"
___:00AE4248 dd offset aC4_zalarm ; "C4_zalarm"
___:00AE424C dd offset aC4_text05 ; "C4_text05"
___:00AE4250 dd offset aC4_text01 ; "C4_text01"
___:00AE4254 dd offset aC4_text06 ; "C4_text06"
___:00AE4258 dd offset aC4_text03 ; "C4_text03"
___:00AE425C dd offset aC4_text07 ; "C4_text07"
___:00AE4260 dd offset aC4_text04 ; "C4_text04"
___:00AE4264 dd offset aC4_text02 ; "C4_text02"
___:00AE4268 dd offset aC4_custom ; "C4_custom"
___:00AE426C dd offset aC4_zalarm ; "C4_zalarm"
___:00AE4270 dd offset aHacking_usb ; "Hacking_USB"
___:00AE4274 dd offset aHacking ; "Hacking"
___:00AE4278 dd offset aHacking_text21 ; "Hacking_text21"
___:00AE427C dd offset aHacking_text31 ; "Hacking_text31"
___:00AE4280 dd offset aHacking_text41 ; "Hacking_text41"
___:00AE4284 dd offset aHacking_text51 ; "Hacking_text51"
___:00AE4288 dd offset aHacking_text61 ; "Hacking_text61"
___:00AE428C dd offset aHacking_text10 ; "Hacking_text10"
___:00AE4290 dd offset aHacking_text09 ; "Hacking_text09"
___:00AE4294 dd offset aHacking_alarm ; "Hacking_alarm"
___:00AE4298 dd offset aInjec_body ; "injec_body"
___:00AE429C dd offset aInjec_mag ; "injec_mag"
___:00AE42A0 dd offset aInjec_pull_rel ; "injec_pull_reload"
___:00AE42A4 dd offset aInjec_qotion ; "injec_qotion"
___:00AE42A8 dd offset aInjec_trigger ; "injec_trigger"
___:00AE42AC dd offset aInjec_body ; "injec_body"
___:00AE42B0 dd offset aInjec_mag2 ; "injec_mag2"
___:00AE42B4 dd offset aInjec_pull_rel ; "injec_pull_reload"
___:00AE42B8 dd offset aInjec_qotion ; "injec_qotion"
___:00AE42BC dd offset aInjec_trigger ; "injec_trigger"
___:00AE42C0 dd offset aInjec_body ; "injec_body"
___:00AE42C4 dd offset aInjec_mag3 ; "injec_mag3"
___:00AE42C8 dd offset aInjec_pull_rel ; "injec_pull_reload"
___:00AE42CC dd offset aInjec_qotion ; "injec_qotion"
___:00AE42D0 dd offset aInjec_trigger ; "injec_trigger"
___:00AE42D4 dd offset aSpanner01 ; "spanner01"
___:00AE42D8 dd offset aMw ; "MW"
___:00AE42DC dd offset aAdre_body ; "adre_body"
___:00AE42E0 dd offset aAdre_cap ; "adre_cap"
___:00AE42E4 dd offset aAdre_cap ; "adre_cap"
___:00AE42E8 dd offset aStami_body ; "stami_body"
___:00AE42EC dd offset aAdre_body ; "adre_body"
___:00AE42F0 dd offset aAdre_cap ; "adre_cap"
___:00AE42F4 dd offset aAdre_selftrit ; "adre_selftrit"
___:00AE42F8 dd offset aDetector_1st ; "detector_1st"
___:00AE42FC dd offset aBinocular_1st ; "binocular_1st"
___:00AE4300 dd offset aFlashmine ; "flashmine"
___:00AE4304 dd offset aMg3_body ; "mg3_body"
___:00AE4308 dd offset aMg3_bullet01 ; "mg3_bullet01"
___:00AE430C dd offset aMg3_bullet02 ; "mg3_bullet02"
___:00AE4310 dd offset aMg3_bullet03 ; "mg3_bullet03"
___:00AE4314 dd offset aMg3_cap ; "mg3_cap"
___:00AE4318 dd offset aMg3_clip ; "mg3_clip"
___:00AE431C dd offset aMg3_cross ; "mg3_cross"
___:00AE4320 dd offset aMg3_mag ; "mg3_mag"
___:00AE4324 dd offset aMg3_reload ; "mg3_reload"
___:00AE4328 dd offset aMinigun_body ; "minigun_body"
___:00AE432C dd offset aMinigun_rot ; "minigun_rot"
___:00AE4330 dd offset aMk1_acc ; "MK1_acc"
___:00AE4334 dd offset aMk1_body ; "MK1_Body"
___:00AE4338 dd offset aMk1_reload ; "MK1_Reload"
___:00AE433C dd offset aMk1_mag ; "MK1_mag"
___:00AE4340 dd offset aHk69_acc ; "HK69_acc"
___:00AE4344 dd offset aHk69_body ; "HK69_Body"
___:00AE4348 dd offset aHk69_bullet ; "HK69_bullet"
___:00AE434C dd offset aHk69_cyl ; "HK69_cyl"
___:00AE4350 dd offset aHk69_reload ; "HK69_reload"
___:00AE4354 dd offset aHk69_bullet__0 ; "HK69_bullet_front"
___:00AE4358 dd offset aHk69_acc ; "HK69_acc"
___:00AE435C dd offset aHk69_bullet_fr ; "HK69_bullet_front_silver"
___:00AE4360 dd offset aHk69_bullet_si ; "HK69_bullet_silver"
___:00AE4364 dd offset aHk69_cyl_silve ; "HK69_cyl_silver"
___:00AE4368 dd offset aHk69_reload_si ; "HK69_reload_silver"
___:00AE436C dd offset aHk69_body_silv ; "HK69_Body_silver"
___:00AE4370 dd offset aAmmobox_body ; "ammobox_body"
___:00AE4374 dd offset aAmmobox_clipl ; "ammobox_clipL"
___:00AE4378 dd offset aAmmobox_clipr ; "ammobox_clipR"
___:00AE437C dd offset aAmmobox_hand ; "ammobox_hand"
___:00AE4380 dd offset aHandmine_body ; "handmine_body"
___:00AE4384 dd offset aHandmine_pin ; "handmine_pin"
___:00AE4388 dd offset aGas1st_pin02 ; "gas1st_pin02"
___:00AE438C dd offset aGas1st_clip01 ; "gas1st_clip01"
___:00AE4390 dd offset aGas1st_body ; "gas1st_body"
___:00AE4394 dd offset aGas1st_pin01 ; "gas1st_pin01"
___:00AE4398 dd offset aMedicbox ; "medicbox"
___:00AE439C dd offset aNip01 ; "nip01"
___:00AE43A0 dd offset aNip02 ; "nip02"
___:00AE43A4 dd offset aHabox_body_dn ; "HAbox_Body_Dn"
___:00AE43A8 dd offset aHabox_body_up ; "HAbox_Body_up"
___:00AE43AC dd offset aHabox_cap_in ; "HAbox_Cap_in"
___:00AE43B0 dd offset aHabox_cap_out ; "HAbox_Cap_out"
___:00AE43B4 dd offset aSnowball_1st ; "snowball_1st"
___:00AE43B8 dd offset aScpn_mag_l ; "scpn_mag_L"
___:00AE43BC dd offset aScpn_mag_r ; "scpn_mag_R"
___:00AE43C0 dd offset aScpn_reload_l_ ; "scpn_reload_L_gold"
___:00AE43C4 dd offset aScpn_body_l_go ; "scpn_body_L_gold"
___:00AE43C8 dd offset aScpn_reload_r_ ; "scpn_reload_R_gold"
___:00AE43CC dd offset aScpn_body_r_go ; "scpn_body_R_gold"
___:00AE43D0 dd offset aG36_reload_in ; "G36_reload_in"
___:00AE43D4 dd offset aG36_reload ; "G36_reload"
___:00AE43D8 dd offset aG36_100_gold ; "G36_100_gold"
___:00AE43DC dd offset aG36c_gold ; "G36C_gold"
___:00AE43E0 dd offset aTmp9_mag_nicke ; "TMP9_mag_nickel"
___:00AE43E4 dd offset aTmp9_reload_ni ; "TMP9_reload_nickel"
___:00AE43E8 dd offset aTmp9_nickel ; "TMP9_nickel"
___:00AE43EC dd offset aMp7_1st_mag ; "mp7_1st_mag"
___:00AE43F0 dd offset aMp7_1st_hand ; "mp7_1st_hand"
___:00AE43F4 dd offset aMp7_1st_reload ; "mp7_1st_reload"
___:00AE43F8 dd offset aMp7_1st_body_g ; "mp7_1st_body_gold"
___:00AE43FC dd offset aAwm_reload01_c ; "AWM_reload01_camo"
___:00AE4400 dd offset aAwm_reload02_c ; "AWM_reload02_camo"
___:00AE4404 dd offset aAwm_mag_camo ; "AWM_mag_camo"
___:00AE4408 dd offset aAwm_body_camo ; "AWM_body_camo"
___:00AE440C dd offset aM82_mag ; "m82_mag"
___:00AE4410 dd offset aM82_reload ; "m82_reload"
___:00AE4414 dd offset aM82_camo ; "m82_camo"
___:00AE4418 dd offset aM60_bullet01 ; "m60_bullet01"
___:00AE441C dd offset aM60_bullet02 ; "m60_bullet02"
___:00AE4420 dd offset aM60_bullet03 ; "m60_bullet03"
___:00AE4424 dd offset aM60_box ; "m60_box"
___:00AE4428 dd offset aM60_leg ; "m60_leg"
___:00AE442C dd offset aM60_cap_gold ; "m60_cap_gold"
___:00AE4430 dd offset aM60_body_gold ; "m60_body_gold"
___:00AE4434 dd offset aG36_reload_in ; "G36_reload_in"
___:00AE4438 dd offset aG36_mag ; "G36_mag"
___:00AE443C dd offset aG36_reload ; "G36_reload"
___:00AE4440 dd offset aG36_camo ; "G36_camo"
___:00AE4444 dd offset aM249_trigger ; "m249_trigger"
___:00AE4448 dd offset aM249_bullet01 ; "m249_bullet01"
___:00AE444C dd offset aM249_bullet02 ; "m249_bullet02"
___:00AE4450 dd offset aM249_bullet03 ; "m249_bullet03"
___:00AE4454 dd offset aM249_mag ; "m249_mag"
___:00AE4458 dd offset aM249_body_nick ; "m249_body_nickel"
___:00AE445C dd offset aM249_open_nick ; "m249_open_nickel"
___:00AE4460 dd offset aMinigun_rot_go ; "minigun_rot_gold"
___:00AE4464 dd offset aMinigun_body_g ; "minigun_body_gold"
___:00AE4468 dd offset aKnife_0 ; "knife"
___:00AE446C dd offset aFknife_3rd ; "Fknife_3rd"
___:00AE4470 dd offset aJapswd ; "japswd"
___:00AE4474 dd offset aJapswd_sheath ; "japswd_sheath"
___:00AE4478 dd offset aThammer3rd ; "thammer3rd"
___:00AE447C dd offset aFknife_3rd ; "Fknife_3rd"
___:00AE4480 dd offset aJapswd ; "japswd"
___:00AE4484 dd offset aJapswd_sheath ; "japswd_sheath"
___:00AE4488 dd offset off_99A228
___:00AE448C dd offset aDersert_gun ; "dersert_gun"
___:00AE4490 dd offset aMp5ka_3rd ; "mp5ka_3rd"
___:00AE4494 dd offset aMagnum ; "magnum"
___:00AE4498 dd offset aGlock_0 ; "glock"
___:00AE449C dd offset aBeretta3rd_l ; "beretta3rd_L"
___:00AE44A0 dd offset aBeretta3rd_r ; "beretta3rd_R"
___:00AE44A4 dd offset aThrowknife3r_0 ; "throwknife3rd_L"
___:00AE44A8 dd offset aThrowknife3rd_ ; "throwknife3rd_R"
___:00AE44AC dd offset aM_uzi ; "m_uzi"
___:00AE44B0 dd offset aBere92f ; "bere92f"
___:00AE44B4 dd offset aMp5ka_3rd_gold ; "mp5ka_3rd_gold"
___:00AE44B8 dd offset aMp5ka_scope_3r ; "mp5ka_scope_3rd"
___:00AE44BC dd offset aAk ; "AK"
___:00AE44C0 dd offset aK2 ; "K2"
___:00AE44C4 dd offset aM4_3rd ; "M4_3rd"
___:00AE44C8 dd offset aFamas ; "FAMAS"
___:00AE44CC dd offset aL85a1 ; "L85A1"
___:00AE44D0 dd offset aXm8 ; "XM8"
___:00AE44D4 dd offset aJ89t ; "J89T"
___:00AE44D8 dd offset aSig550_3rd ; "SIG550_3rd"
___:00AE44DC dd offset aTar21 ; "tar21"
___:00AE44E0 dd offset aM16a4_3rd ; "m16a4_3rd"
___:00AE44E4 dd offset aAn94 ; "an94"
___:00AE44E8 dd offset aM16a4_silver_3 ; "m16a4_silver_3rd"
___:00AE44EC dd offset aAk_scope ; "AK_scope"
___:00AE44F0 dd offset aM4_3rd_gold ; "M4_3rd_gold"
___:00AE44F4 dd offset aG36_mag ; "G36_mag"
___:00AE44F8 dd offset aG36c ; "G36C"
___:00AE44FC dd offset aG36c ; "G36C"
___:00AE4500 dd offset aG36drum ; "G36drum"
___:00AE4504 dd offset aAks74u ; "aks74u"
___:00AE4508 dd offset aG36_mag ; "G36_mag"
___:00AE450C dd offset aHkg36 ; "HKG36"
___:00AE4510 dd offset aG36drum ; "G36drum"
___:00AE4514 dd offset aHkg36 ; "HKG36"
___:00AE4518 dd offset aHkmp5_3rd ; "HKmp5_3rd"
___:00AE451C dd offset aP90_3rd ; "P90_3rd"
___:00AE4520 dd offset aUzi_3rd ; "UZI_3rd"
___:00AE4524 dd offset aTmp9_3rd ; "TMP9_3rd"
___:00AE4528 dd offset aK1 ; "K1"
___:00AE452C dd offset aMp7_3rd ; "mp7_3rd"
___:00AE4530 dd offset aScrp3rd_l ; "scrp3rd_L"
___:00AE4534 dd offset aScrp3rd_r ; "scrp3rd_R"
___:00AE4538 dd offset aSpectre_0 ; "spectre"
___:00AE453C dd offset aMac10m ; "Mac10m"
___:00AE4540 dd offset aUmp45 ; "ump45"
___:00AE4544 dd offset aCx4_3rd ; "cx4_3rd"
___:00AE4548 dd offset aP90_silver_3rd ; "P90_silver_3rd"
___:00AE454C dd offset aK1_gold ; "K1_gold"
___:00AE4550 dd offset aCx4_3rd_digit ; "cx4_3rd_digit"
___:00AE4554 dd offset aPsg1 ; "psg-1"
___:00AE4558 dd offset aM82 ; "m82"
___:00AE455C dd offset aAug_3rd ; "aug_3rd"
___:00AE4560 dd offset aSsg69 ; "ssg69"
___:00AE4564 dd offset aM24 ; "m24"
___:00AE4568 dd offset off_99A048
___:00AE456C dd offset off_99A044
___:00AE4570 dd offset aAw50f ; "AW50F"
___:00AE4574 dd offset dword_993C54
___:00AE4578 dd offset aWa2000 ; "wa2000"
___:00AE457C dd offset aM40a1_3rd ; "m40a1_3rd"
___:00AE4580 dd offset aAwm_gold ; "awm_gold"
___:00AE4584 dd offset aPsg1_red ; "psg-1_red"
___:00AE4588 dd offset aSsg69_silver ; "ssg69_silver"
___:00AE458C dd offset aM60_3rd ; "m60_3rd"
___:00AE4590 dd offset aM249 ; "M249"
___:00AE4594 dd offset aSg_winch ; "SG_winch"
___:00AE4598 dd offset aM4super90_3rd ; "m4super90_3rd"
___:00AE459C dd offset aPanzer_body ; "panzer_body"
___:00AE45A0 dd offset aPanzer_rok ; "panzer_rok"
___:00AE45A4 dd offset aRpg7_3rd ; "rpg7_3rd"
___:00AE45A8 dd offset aJavelin_3rd ; "javelin_3rd"
___:00AE45AC dd offset aJavelin_3rd_cy ; "Javelin_3rd_cyl"
___:00AE45B0 dd offset aRpg7_3rd_gold ; "rpg7_3rd_gold"
___:00AE45B4 dd offset aRpg7_3rd_night ; "rpg7_3rd_night"
___:00AE45B8 dd offset aStinger ; "stinger"
___:00AE45BC dd offset aMine_3rd ; "mine_3rd"
___:00AE45C0 dd offset aGran ; "gran"
___:00AE45C4 dd offset aGran ; "gran"
___:00AE45C8 dd offset aSmoke_gra ; "smoke_gra"
___:00AE45CC dd offset aFlash_gra ; "flash_gra"
___:00AE45D0 dd offset aFlash_gra ; "flash_gra"
___:00AE45D4 dd offset aClamoa_3rd ; "clamoa_3rd"
___:00AE45D8 dd offset aCla3rd_btn ; "cla3rd_btn"
___:00AE45DC dd offset aPda_3rd ; "PDA_3rd"
___:00AE45E0 dd offset aC4_3rd ; "C4_3rd"
___:00AE45E4 dd offset aC4_3rd_custom ; "C4_3rd_custom"
___:00AE45E8 dd offset aHacking_3rd ; "Hacking_3rd"
___:00AE45EC dd offset aInject_3rd ; "inject_3rd"
___:00AE45F0 dd offset aInject_3rd ; "inject_3rd"
___:00AE45F4 dd offset aInject_3rd ; "inject_3rd"
___:00AE45F8 dd offset aSpanner_3rd ; "spanner_3rd"
___:00AE45FC dd offset aSpanner_3rd ; "spanner_3rd"
___:00AE4600 dd offset aMw_3rd ; "mw_3rd"
___:00AE4604 dd offset aAdre ; "adre"
___:00AE4608 dd offset aParachute_0 ; "parachute"
___:00AE460C dd offset aStami ; "stami"
___:00AE4610 dd offset aAdre ; "adre"
___:00AE4614 dd offset aDetector3rd ; "detector3rd"
___:00AE4618 dd offset aBinocular_3rd ; "binocular_3rd"
___:00AE461C dd offset aFlashmine ; "flashmine"
___:00AE4620 dd offset aMg3_low ; "mg3_low"
___:00AE4624 dd offset aMinigun ; "minigun"
___:00AE4628 dd offset aMk1_3rd ; "MK1_3rd"
___:00AE462C dd offset aHk69 ; "HK69"
___:00AE4630 dd offset aHk69_silver ; "HK69_silver"
___:00AE4634 dd offset aAmmo_3rd ; "ammo_3rd"
___:00AE4638 dd offset aHandmine_3rd ; "handmine_3rd"
___:00AE463C dd offset aMedicbox ; "medicbox"
___:00AE4640 dd offset off_999E70
___:00AE4644 dd offset aHabox_3rd ; "HAbox_3rd"
___:00AE4648 dd offset aSnowball_3rd ; "snowball_3rd"
___:00AE464C dd offset aScrp3rd_l_gold ; "scrp3rd_L_gold"
___:00AE4650 dd offset aScrp3rd_r_gold ; "scrp3rd_R_gold"
___:00AE4654 dd offset aG36c_gold ; "G36C_gold"
___:00AE4658 dd offset aG36drum_gold ; "G36drum_gold"
___:00AE465C dd offset aTmp9_3rd_nicke ; "TMP9_3rd_nickel"
___:00AE4660 dd offset aMp7_3rd_gold ; "mp7_3rd_gold"
___:00AE4664 dd offset aAwm_camo ; "awm_camo"
___:00AE4668 dd offset aM82_camo ; "m82_camo"
___:00AE466C dd offset aM60_3rd_gold ; "m60_3rd_gold"
___:00AE4670 dd offset aG36_mag ; "G36_mag"
___:00AE4674 dd offset aHkg36_camo ; "HKG36_camo"
___:00AE4678 dd offset aM249_nickel ; "m249_nickel"
___:00AE467C dd offset aMinigun_gold ; "minigun_gold"

New =>

___:00AE7E88 dd offset aKnife_1st ; "knife_1st"
___:00AE7E8C dd offset aFknife_1st ; "Fknife_1st"
___:00AE7E90 dd offset off_99CF34
___:00AE7E94 dd offset aSwd_cover ; "swd_cover"
___:00AE7E98 dd offset aThammer1st ; "thammer1st"
___:00AE7E9C dd offset aFknife_1st ; "Fknife_1st"
___:00AE7EA0 dd offset off_99CF34
___:00AE7EA4 dd offset aSwd_cover ; "swd_cover"
___:00AE7EA8 dd offset aColt_body ; "Colt_body"
___:00AE7EAC dd offset aColt_mag ; "Colt_mag"
___:00AE7EB0 dd offset aColt_reload ; "Colt_reload"
___:00AE7EB4 dd offset aColt_trigger ; "Colt_trigger"
___:00AE7EB8 dd offset aColt_trigger02 ; "Colt_trigger02"
___:00AE7EBC dd offset aDer_body ; "der_body"
___:00AE7EC0 dd offset aDer_mag ; "der_mag"
___:00AE7EC4 dd offset aDer_reload ; "der_reload"
___:00AE7EC8 dd offset aDer_trigger ; "der_trigger"
___:00AE7ECC dd offset aMp5ka_body ; "MP5ka_body"
___:00AE7ED0 dd offset aMp5ka_mag ; "MP5ka_mag"
___:00AE7ED4 dd offset aMp5ka_reload ; "MP5ka_reload"
___:00AE7ED8 dd offset aMp5ka_trigger ; "MP5ka_trigger"
___:00AE7EDC dd offset aRevolver_body ; "revolver_body"
___:00AE7EE0 dd offset aRevolver_bul_4 ; "revolver_bullet01"
___:00AE7EE4 dd offset aRevolver_bul_3 ; "revolver_bullet02"
___:00AE7EE8 dd offset aRevolver_bul_2 ; "revolver_bullet03"
___:00AE7EEC dd offset aRevolver_bul_1 ; "revolver_bullet04"
___:00AE7EF0 dd offset aRevolver_bul_0 ; "revolver_bullet05"
___:00AE7EF4 dd offset aRevolver_bulle ; "revolver_bullet06"
___:00AE7EF8 dd offset aRevolver_newbu ; "revolver_newbullet"
___:00AE7EFC dd offset aRevolver_rel_0 ; "revolver_reload01"
___:00AE7F00 dd offset aRevolver_reloa ; "revolver_reload02"
___:00AE7F04 dd offset aRevolver_sploa ; "revolver_sploader"
___:00AE7F08 dd offset aRevolver_trige ; "revolver_triger"
___:00AE7F0C dd offset aGlock_body ; "glock_body"
___:00AE7F10 dd offset aGlock_mag ; "glock_mag"
___:00AE7F14 dd offset aGlock_reloader ; "glock_reloader"
___:00AE7F18 dd offset aGlock_tigger ; "glock_tigger"
___:00AE7F1C dd offset aBeretta1st_l_b ; "beretta1st_L_body"
___:00AE7F20 dd offset aBeretta1st_l_m ; "beretta1st_L_mag"
___:00AE7F24 dd offset aBeretta1st_l_r ; "beretta1st_L_reload"
___:00AE7F28 dd offset aBeretta1st_r_b ; "beretta1st_R_body"
___:00AE7F2C dd offset aBeretta1st_r_m ; "beretta1st_R_mag"
___:00AE7F30 dd offset aBeretta1st_r_r ; "beretta1st_R_reload"
___:00AE7F34 dd offset aThrowknife1s_0 ; "throwknife1st_L"
___:00AE7F38 dd offset aThrowknife1st_ ; "throwknife1st_R"
___:00AE7F3C dd offset aMuzi_mag ; "muzi_mag"
___:00AE7F40 dd offset aMuzi_reload ; "muzi_reload"
___:00AE7F44 dd offset aMuzi_body ; "muzi_body"
___:00AE7F48 dd offset aBeretta92_body ; "beretta92_body"
___:00AE7F4C dd offset aBeretta92_hamm ; "beretta92_hammer"
___:00AE7F50 dd offset aBeretta92_mag ; "beretta92_mag"
___:00AE7F54 dd offset aBeretta92_slid ; "beretta92_slide"
___:00AE7F58 dd offset aMp5ka_reload ; "MP5ka_reload"
___:00AE7F5C dd offset aMp5ka_trigger ; "MP5ka_trigger"
___:00AE7F60 dd offset aMp5ka_mag_gold ; "MP5ka_mag_gold"
___:00AE7F64 dd offset aMp5ka_body_gol ; "MP5ka_body_gold"
___:00AE7F68 dd offset aMp5ka_mag ; "MP5ka_mag"
___:00AE7F6C dd offset aMp5ka_reload ; "MP5ka_reload"
___:00AE7F70 dd offset aMp5ka_trigger ; "MP5ka_trigger"
___:00AE7F74 dd offset aMp5ka_body_sco ; "MP5ka_body_scop"
___:00AE7F78 dd offset aAk_ac ; "AK_ac"
___:00AE7F7C dd offset aAk_body ; "AK_body"
___:00AE7F80 dd offset aAk_mag ; "AK_mag"

Encuentro con la Ciencia, por Modesto Montoya. Juan Rodríguez y planes de gobierno

2011-05-27T11:29:00.001-07:00

Algo que se debe de tomar en cuenta para estas elecciones, tarde pero vale la pena escuchar lo que se comenta.

Sin investigacion un Pais no lograra desarrollarse y avanzar y solo dependera de otros y no de si mismo.

Undetected Endscene Hook [ GAMEGUARD ]

2011-04-27T09:05:00.004-07:00

1. ] Some Says Hooking vtables are now detected, can i still Hook it withouth being kicked..??

2. ] Does GameGuard Scan The Whole d3d functions or just the modified vtable??

BTW im Hooking The Endscene of " Special Force [ soldierfront ] " but Gameguard always Kick Me Off..

Undetected directx hook

2011-04-27T09:05:00.002-07:00

So, first of all, I am using Windows7 Build 7100, and XP is NOT supported by this method, since the driver model only applies to vista and above.

I was wondering how I could make a undetected directx hook, and I was searching some subfunctions. Eventually I came out by a function called pfnPresentCb. This is documented by microsoft: http://msdn.microsoft.com/en-us/library/ms791726.aspx

In Windows vista + windows 7, you can use this function to hook undetected. The reason why it still allows drawing, is because the buffer hasnt been flipped yet(there is also a pfnRender function, and that doesnt work because of this( tnx roverturbo ^^ ) ). So, it will look like this:

Code:

HRESULT APIENTRY npfnPresentCb( HANDLE pDevice, LPVOID pData )//remember that pDevice is not the d3d device :p
{
 _asm pushad;
 
 RenderFrame();

 _asm popad;

 HRESULT hRet = ppfnPresentCb( pDevice, pData ); 
 return hRet; 
}

Since this is a kernel usermode driver function( if you'll follow the calls, you'll see this calls the driver functions ), pb doesnt scan it( prolly gameguard/hackshield doesnt as well ).

The function is located @ d3d9 + 0x7B3F in windows7, build 7100. I am just giving you some ideas, since some of you around here are having a hard time with anti-cheat. This is why they fail

You can also hook gdi functions or so, or hook even deeper, or even hook the drivers.

This is very OS dependent, and wont even work on xp. Thats why I am releasing it, so pays*tes cant use it

Have fun,

R4z8r

Xtrap bypass

2011-04-27T09:05:00.000-07:00

To Game: S4League

PHP Code:

  #include  



#define HackDetect1 0x00435FA6 BYTE HD1[] = {0xEB, 0x35}; #define HackDetect2 0x0043CE36 BYTE HD2[] = {0xEB, 0x35}; #define HackDetect3 0x0043DCF0 BYTE HD3[] = {0xEB, 0x35}; #define HackDetect4 0x0043DCD1 BYTE HD4[] = {0xEB, 0x1F}; #define HackDetect5 0x0043DCE9 BYTE HD5[] = {0xEB, 0x07}; #define IsDebuggerPresent 0x00499517 BYTE IDP[] = {0x90}; #define ZCheckHackProcess1 0x00441E35 BYTE ZCHP1[] = {0xEB, 0x34}; #define ZCheckHackProcess2 0x00441E62 BYTE ZCHP2[] = {0xEB, 0x2C}; #define ZCheckHackProcess3 0x00441EBD BYTE ZCHP3[] = {0xEB, 0x09}; #define AbnormalBehavior 0x00440353 BYTE AB[] = {0xE9, 0x8A, 0x00, 0x00, 0x00}; DWORD OldProtection; void WriteToMemory(DWORD Offset, DWORD Pointer, DWORD Length){ VirtualProtect((void *)Offset, Length, PAGE_EXECUTE_READWRITE, &OldProtection); RtlMoveMemory((void *)Offset, (const void*)Pointer, Length); VirtualProtect((void *)Offset, Length, OldProtection, &OldProtection); 

} void ModifyMemory( BYTE *Offset, BYTE *ByteArray, DWORD Length){ 

for(DWORD i = 0; i < Length; i++) WriteToMemory((DWORD)Offset + i, (DWORD)ByteArray + i, 1); 

} void Bypass() 

{ ModifyMemory((BYTE*)HackDetect1, HD1, 2); ModifyMemory((BYTE*)HackDetect2, HD2, 2); ModifyMemory((BYTE*)HackDetect4, HD4, 2); ModifyMemory((BYTE*)HackDetect5, HD5, 2); ModifyMemory((BYTE*)AbnormalBehavior, AB, 5); 

} 

bool APIENTRY DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpvReserved){ 

if(dwReason == DLL_PROCESS_ATTACH){ DisableThreadLibraryCalls(hModule); Bypass(); 

return true; 

} 

return true; 

}

[C++]X-Trap Bypass

2011-04-27T09:04:00.000-07:00

Simply compile in C++ as a DLL and inject.

Source:

Code:

/*********************************************************************
** XTrap Bypass                      **
**********************************************************************
** Hacking Detected             **
** ----------------             **
** 00435FA6 EB 35 All referenced text string, 'Hacking detected' **
**      One line, up, change JNZ to JMP     **
** 0043CE36 EB 35 All referenced text string, 'Hacking detected' **
**      One line, up, change JNZ to JMP     **
** 0043DCF0 EB 35 All referenced text string, 'Hacking detected' **
**      One line, up, change JNZ to JMP     **
** 0043DCD1 EB 1F All referenced text string, 'Hacking detected' **
**      Jump #1 change JNZ to JMP       **
** 0043DCE9 EB 07 All referenced text string, 'Hacking detected' **
**      Jump #2 change JNZ to JMP       **
**                 **
** IsDebuggerPresent            **
** -----------------            **
** 00499517 90 Go to IsDebuggerPresent, do down and NOP first JNZ **
**                 **
** ZCheckHackProcess            **
** -----------------            **
** 00441E35 EB 34 All referenced text string, 'Hacking Detected' **
**      go up till start of function (PUSH -1),   **
**      go to the local call, under it theres a   **
**      TEST AL,AL, go down one more line, (JNZ) change **
**      it to JMP (Do this for all 3 'Hacking Detected' **
** 00441E62 EB 2C             **
** 00441EBD EB 09             **
**                 **
** Abnormal Behavior            **
** -----------------            **
** 00440353 E9 8A 00 00 00 All referenced text strings,    **
**         'An abnormal behavior is detected.',  **
**         go up 2 lines, change the JE to JMP  **
*********************************************************************/

#include 

#define HackDetect1 0x00435FA6
BYTE HD1[] = {0xEB, 0x35};
#define HackDetect2 0x0043CE36
BYTE HD2[] = {0xEB, 0x35};
#define HackDetect3 0x0043DCF0
BYTE HD3[] = {0xEB, 0x35};
#define HackDetect4 0x0043DCD1
BYTE HD4[] = {0xEB, 0x1F};
#define HackDetect5 0x0043DCE9
BYTE HD5[] = {0xEB, 0x07};
#define IsDebuggerPresent 0x00499517
BYTE IDP[] = {0x90};
#define ZCheckHackProcess1 0x00441E35
BYTE ZCHP1[] = {0xEB, 0x34};
#define ZCheckHackProcess2 0x00441E62
BYTE ZCHP2[] = {0xEB, 0x2C};
#define ZCheckHackProcess3 0x00441EBD
BYTE ZCHP3[] = {0xEB, 0x09};
#define AbnormalBehavior 0x00440353
BYTE AB[] = {0xE9, 0x8A, 0x00, 0x00, 0x00};

//Write To Memory
DWORD OldProtection;
void WriteToMemory(DWORD Offset, DWORD Pointer, DWORD Length){
    VirtualProtect((void *)Offset, Length, PAGE_EXECUTE_READWRITE, &OldProtection);
    RtlMoveMemory((void *)Offset, (const void*)Pointer, Length);
    VirtualProtect((void *)Offset, Length, OldProtection, &OldProtection);
}
void ModifyMemory( BYTE *Offset, BYTE *ByteArray, DWORD Length){
    for(DWORD i = 0; i < Length; i++)
        WriteToMemory((DWORD)Offset + i, (DWORD)ByteArray + i, 1);
}

void Bypass()
{
 ModifyMemory((BYTE*)HackDetect1, HD1, 2);
 ModifyMemory((BYTE*)HackDetect2, HD2, 2);
 //ModifyMemory((BYTE*)HackDetect3, HD3, 2);
 ModifyMemory((BYTE*)HackDetect4, HD4, 2);
 ModifyMemory((BYTE*)HackDetect5, HD5, 2);
 //ModifyMemory((BYTE*)IsDebuggerPresent, IDP, 1);
 //ModifyMemory((BYTE*)ZCheckHackProcess1, ZCHP1, 2);
 //ModifyMemory((BYTE*)ZCheckHackProcess2, ZCHP2, 2);
 //ModifyMemory((BYTE*)ZCheckHackProcess3, ZCHP3, 2);
 ModifyMemory((BYTE*)AbnormalBehavior, AB, 5);
}

bool APIENTRY DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpvReserved){
 if(dwReason == DLL_PROCESS_ATTACH){
  DisableThreadLibraryCalls(hModule);
  Bypass();
  return true;
 }
 return true;
}

Don't ask how to compile it. If you can't compile it you don't deserve it.
Works for all versions of xtrap to date.

Edit: Posted in the wrong section..Someone can move it if needed =)

[Tutorial] How to make an Crosshair

2011-04-27T09:01:00.001-07:00

FIRST:I ONLY COPIED THE WHOLEN THREAD BECAUSE IT WILL HELP SOME CROSSFIRE CODER.

How To make You First CrossHair hack
This Tutorial will show you how to make begginer , crosshair hack . The program am using is called Visual Studio C++ [2010] , you can download 30day trial .
The SourceCode am using is not made by me , its made by some other guy am just using it to show you guys how to use SourceCodes [ if you know this dont post any crap comments ]
thanks .
{ i will include the source code here ]
This CrossHair only works in Window Mode
Works for any Game :P
Press Numpad0 to turn it on / off

TUTORIAL IS MADE BY LoveKiss
thanks to him
Source Code :

Code:

#include 
#include 
#include 
using namespace std;

bool crosshairon=false;
HDC ragedc = NULL;
int crosshairsize=0;
int cx=0;
int cy=0;

void CrossThread(void)
{
    while(1)
    {
        if(GetAsyncKeyState(VK_NUMPAD0)&1)
        {
            crosshairon=!crosshairon;
            ragedc = GetDC(HWND_DESKTOP);
            cx=GetSystemMetrics(SM_CXSCREEN)/2-((crosshairsize-1)/2);
            cy=GetSystemMetrics(SM_CYSCREEN)/2-((crosshairsize-1)/2);
        }
        Sleep(1);
    }
}

int main()
{
    cout<<"Crosshair size in pixels:\n";
    cin>>crosshairsize;
    if(crosshairsize%2==0)
    {
        crosshairsize+=1; 
    }
    system("cls"); 
    cout<<"Press numpad0 to toggle the crosshair on and off\n";
    CreateThread(0,0,(LPTHREAD_START_ROUTINE)CrossThread,0,0,0);
    while(1)
    {
        if(crosshairon==true)
        {
            for(int i=0;i
            {
                SetPixel(ragedc, cx+i, cy+((crosshairsize-1)/2), RGB(255,0,0));
                SetPixel(ragedc, cx+((crosshairsize-1)/2), cy+i, RGB(0,0,255));
            }

            if(crosshairon==false)
        
            for(int i=1;i
            {
                SetPixel(ragedc, cx+i, cy+((crosshairsize-1)/2), RGB(0,0,0));
                SetPixel(ragedc, cx+((crosshairsize-1)/2), cy+i, RGB(0,0,0));
            }
        }
        Sleep(33);
    }
}

Thank LoveKiss - Not Me

[Tutorial] How to make a Addy Logger

2011-04-27T09:00:00.001-07:00

Today I'm showing you guys how to create your own addie logger!
CREDITZ: Dean-Wingess and NeoI.I.I - I only fixed some function errors
First of all create a normal project in C++.
Make it Win32 Dll without precompiled headers.

First of all we create the Functions!

We need to create a Header called: Log.h

Create it and paste:

Code:

char *GetDirectoryFile(char *filename);
void __cdecl Writelog (const char * fmt, ...);
void logging(HMODULE hDll);
#pragma message("master.h : Building Addylogger. Credits:Dean-Wingess, Neo I.I.I")

Save it

Then we need the Find pattern function!
create a header called: Pattern.h
And Paste:

Code:

DWORD dwSize;
DWORD dwStartAddress;

BOOL bCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
for(;*szMask;++szMask,++pData,++bMask)
{
if(*szMask == 'x' && *pData != *bMask)
return 0;
}
return (*szMask)==NULL;
}


DWORD FindPattern(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask)
{
for(DWORD i=0; i < dwLen; i++)
if( bCompare( (BYTE*)( dwAddress+i ),bMask,szMask) )
return (DWORD)(dwAddress+i);
return 0;
}

After that we finished on creating the functions.

Create the Cpp Files:
Log.cpp

Paste:

Code:

#include 
#include 
#include 
#include 
#include 


using namespace std;

ofstream ofile;
char dlldirectory[320];

char *GetDirectoryFile(char *filename)
{
static char path[320];
strcpy(path, dlldirectory);
strcat(path, filename);
return path;
}

void __cdecl Writelog(const char *fmt, ...)
{
if(ofile != NULL)
{
if(!fmt) { return; }
va_list va_alist;
char logbuf[256] = {0};
va_start (va_alist, fmt);
_vsnprintf (logbuf+strlen(logbuf), sizeof(logbuf) - strlen(logbuf), fmt, va_alist);
va_end (va_alist);
ofile << logbuf << endl;
}}

void logging(HMODULE hDll){
DisableThreadLibraryCalls(hDll);
GetModuleFileName(hDll, dlldirectory, 512);
for(int i = strlen(dlldirectory); i > 0; i--) { if(dlldirectory[i] == '\\') { dlldirectory[i+1] = 0; break; } }
ofile.open(GetDirectoryFile("Adresses.txt"), ios::app); // here put the output filename
}

Main.cpp
paste:

Code:

#include 
#include 
#include "Log.h"
#include "Pattern.h"

bool IsGameReadyForHook()
{
if( GetModuleHandleA( "ClientFX.fxd" ) != NULL 
&& GetModuleHandleA( "CShell.dll" ) != NULL )
return true;

return false;
}

void SearchPatterns(void)
{
while (!IsGameReadyForHook()){
Sleep(50);
}
while(true){
dwSize = 0x500000; 

//Example DWORD dwPlayerPointer = FindPattern((PBYTE)"\x00\x00\x00\x00\x00\x00\x00};", "x????xxxx", 1, true);

DWORD nametags1 = FindPattern((DWORD)GetModuleHandleA("CShell.dll"), 0x9c0000, (PBYTE)"\x75\x21\x80\x7B\x00\x00", "xxxx??");
DWORD nametags2 = FindPattern((DWORD)GetModuleHandleA("CShell.dll"), 0x9c0000, (PBYTE)"\x75\x05\xBD\x00\x00\x00\x00\x8B\x17", "xxx????xx");
//-------------------------------------------------------------//
Writelog("//==============Dean-Wingess N3x0n Logger==============\\");
Writelog("//==============Created and developed by:==============\\");
Writelog("//======================Dean-Wingess===================\\");
Writelog("//====================== Neo I.I.I ===================\\");
Writelog("//====================== FlaVour ===================\\");
Writelog("");
Writelog("#define NoReload 0x%X",NoReload);
Writelog("#define FallDamage 0x%X",FallDamage);


Writelog("");
Writelog("//*************************Next log*********************************");



ExitProcess(0);
}
}

BOOL WINAPI DllMain ( HMODULE hDll, DWORD dwReason, LPVOID lpReserved )
{
DisableThreadLibraryCalls(hDll);
if (dwReason==DLL_PROCESS_ATTACH)
{
logging(hDll);
ShellExecuteA(0,"open","http://mpgh.net",0,0,SW_MINIMIZE);
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SearchPatterns, NULL, NULL, NULL);
}
return TRUE;
}

WARNING:THE PATTERN ARE OLD - IAM TO LAZY TO GET THE NEWEST

Please dont ask questions like "what i have to do with it."
its for people,who understand c++!

[Source]Crossfire Speed Hack

2011-04-27T08:59:00.001-07:00

[Source] Crossfire Speed Hack Code:
#include
#include

int Speedhack=0;

DWORD CShellBase = (DWORD) GetModuleHandle("cshell.dll");
DWORD SpeedHack = CShellBase + 0x5BE458;

void Speed()
{
while(1){
if(GetAsyncKeyState(VK_NUMPAD1)&1){
Speedhack++;
if(Speedhack > 2){Speedhack=1;};
}
if (Speedhack==1){ // Faster
*(DWORD*)(*(DWORD*)SpeedHack) = 0x46A29CE8;
*(DWORD*)((*(DWORD*)SpeedHack) + 0x20) = 0x46A29CE8;
}
if(Speedhack==2){ // Normal Speed Value
*(DWORD*)(*(DWORD*)SpeedHack) = 0x45938DF8;
*(DWORD*)((*(DWORD*)SpeedHack) + 0x20) = 0x45938DF8;
}
Sleep(100);
}
}

BOOL WINAPI DllMain(HINSTANCE module, DWORD dwReason, LPVOID lpvReserved)
{
if(dwReason == DLL_PROCESS_ATTACH)
{
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)Speed, NULL, NULL, NULL);
}
return TRUE;
}

Credits To Zackth14 And Me For Posting Here
Rep And Thanks

here's my implementation: (modified md5 & aes libs and ollydbg lib is missing):

2011-04-27T08:19:00.000-07:00

HShieldEmu.h

#ifndef __HACKSHIELDEMU_H

#define __HACKSHIELDEMU_H



#include "global.h"

struct hshield_packet_ack_server {

  DWORD IntegrityCheck1_offset_ragII_exe;

  DWORD IntegrityCheck1_size_ragII_exe;

  DWORD VerfiyCheck_data;

  DWORD enabled_checks;

  DWORD MemoryCheck_function_adresses[32];

};

struct hshield_packet_ack_client {

  DWORD VerifyCheck_checksum[2];

  BYTE IntegrityCheck1_checksum[16];

  BYTE MemoryCheck_checksum[16];

  BYTE IntegrityCheck2_checksum[16];

  BYTE IntegrityCheck3_checksum[16];

};





static class HackShieldEmu {



    enum doHShieldCheckFlags {

      doMemoryCheck = 1,     // calculate checksums of function addresses given by the server

      doIntegrityCheck1 = 2, // calculate checksum of RagII.exe

      doIntegrityCheck2 = 4, // calculate checksum of Ehsvc.dll and EGRNAP.dll

      doIntegrityCheck3 = 8, // calculate checksum of v3warpds.v3d and v3warpns.v3d

    };





    // hshield MakeGUIDAckMsg() and MakeGUIDAck() functions

    //



    // calculates the GUIDAck answer for given challenge input (20 bytes)

    // output is 20 bytes

    // reuturns 0 if successful

    int MakeGUIDAckMsg(unsigned char *input, unsigned char *ack_answer);



    // input: 160 bytes from server->client ack packet

    // ack_answer: 72 bytes for the client->server packet

    // returns 0 if succesful

    int MakeAckMSG(unsigned char *input, unsigned char *ack_answer);





    // input: the first 16 bytes from hshield server packet

    // output: 16 bytes aes key

    void calculate_hshield_aeskey(unsigned char* input, unsigned char* output)

   

    // internal functions, not documented here

    int GetCustumMD5OfFile(char *filename,DWORD offset, DWORD size, BYTE *output);



    int GetMemoryCheckData(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer);

    int GetIntegrityCheck1Data(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer);

    int GetIntegrityCheck2Data(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer);

    int GetIntegrityCheck3Data(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer);







    // hshield.log de-/encryption functions

    //

    // format of a hshield.log file:

    //

    // struct hshield_log_file {

    //   hshield_log_entry entries[x];

    // };   

    //

    // struct hshield_log_entry {

    //   int log_size;

    //   unsigned char log_data[log_size];

    // };

    //



    // output: pointer to the output buffer (must have same size as input buffer)

    // input: pointer to the input buffer

    // sizeInput: size of the input buffer (in bytes)

    // key: key used for de-/encryption (RO2 default key is 1252)

    int encrypt_logfile_data(unsigned char *output, unsigned char *input, int sizeInput,DWORD key = 1252);

    int decrypt_logfile_data(unsigned char *output, unsigned char *input, int sizeInput,DWORD key = 1252);



};

#endif

HShieldEmu.cpp

#include "HackShieldEmu.h"

int HackShieldEmu::MakeGUIDAckMsg(unsigned char *input, unsigned char *ack_answer)

{

   unsigned char *encryption_key = new unsigned char[16];

   calculate_hshield_aeskey(&input[0],encryption_key);



   unsigned char guid_of_EhSvc_dll[]= { 0xF6 , 0x33 , 0x08 , 0x58 , 0x90 , 0x28 , 0x80 , 0x44 , 0x81 , 0xDF , 0xA5 , 0xC9 , 0x19 , 0x6D , 0x46 , 0xF7 };



   memcpy(&guid_answer[4],guid_of_EhSvc_dll,16);



   unsigned char *decrypted_input = new unsigned char[4];

   Decrypt(&input[16],4, decrypted_input, encryption_key);



   DWORD *a1 = (DWORD*)&decrypted_input[0];

   DWORD *a2 = (DWORD*)&guid_answer[0];

    *a2 = -1658038656 & (((*a1 >> 11) ^ *a1) << 7) ^ (*a1 >> 11) ^ *a1;



   Encrypt(ack_answer,20,guid_answer,encryption_key);



   delete[] encryption_key;

   delete[] decrypted_input;



   return 0;

}



int HackShieldEmu::MakeAckMSG(unsigned char *input, unsigned char *ack_answer)

{

   hshield_packet_ack_client *ackAnswer = (hshield_packet_ack_client*)ack_answer;

   memset(ackAnswer,0,72);



   unsigned char *encryption_key = new unsigned char[16];

   calculate_hshield_aeskey(&input[0],encryption_key);



   hshield_packet_ack_server *ackData = new hshield_packet_ack_server();

   Decrypt(&input[16],144, (BYTE*)ackData, encryption_key);



   // always do VerifyCheck

   ackAnswer->VerifyCheck_checksum[0] = -1658038656 & (((ackData->VerfiyCheck_data >> 11) ^ ackData->VerfiyCheck_data) << 7) ^ (ackData->VerfiyCheck_data >> 11) ^ ackData->VerfiyCheck_data;

   ackAnswer->VerifyCheck_checksum[1] = ackData->VerfiyCheck_data ^ (ackData->VerfiyCheck_data << 15);

 

   // do MemoryCheck if requested

   if(ackData->enabled_checks & doMemoryCheck) {

     if(GetMemoryCheckData(ackData,ackAnswer)) return 1;

   }



   // do IntegrityCheck1 if requested

   if(ackData->enabled_checks & doIntegrityCheck1) {

     if(GetIntegrityCheck1Data(ackData,ackAnswer)) return 2;

   }



   // do IntegrityCheck2 if requested

   if(ackData->enabled_checks & doIntegrityCheck2) {

     if(GetIntegrityCheck2Data(ackData,ackAnswer)) return 3;

   }



   // do IntegrityCheck3 if requested

   if(ackData->enabled_checks & doIntegrityCheck3) {

     if(GetIntegrityCheck3Data(ackData,ackAnswer)) return 4;

   }



   Encrypt((BYTE*)ackAnswer,72,(BYTE*)ackAnswer,encryption_key);



   delete[] encryption_key;

   delete ackData;



   return 0;

}



int HackShieldEmu::GetCustumMD5OfFile(char *filename,DWORD offset, DWORD size, BYTE *output)

{

  ifstream file (filename, ios::in|ios::binary|ios::ate);

  if (file.is_open())

  {

    ifstream::pos_type fsize = file.tellg();

    DWORD ifsize = (DWORD)fsize;

    BYTE *filebuf = new unsigned char [fsize];

    file.seekg (0, ios::beg);

      file.read((char*)filebuf, fsize);

    file.close();



    md5_state_t state;

    md5_init(&state);

      

    if(offset || size) {

        md5_append_hshield(&state, &filebuf[offset], size);

        md5_append_hshield(&state, &filebuf[0], ifsize);



    }

    else {

        md5_append_hshield(&state, &filebuf[0], 40);

        md5_append_hshield(&state, &filebuf[60], ifsize-60);

    }



    md5_finish_hshield(&state, output);





    delete[] filebuf;



    return 0;

  }



  return 1;

}

int HackShieldEmu::GetMemoryCheckData(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer)

{

    md5_state_t state;

    md5_init(&state);

   

    for(int i=0; i<32; i++) {

       if(ackData->MemoryCheck_function_adresses[i] == 0) break;

     

       DWORD pointer =  ackData->MemoryCheck_function_adresses[i];

       DWORD len = 0;



       while(true) {

           t_disasm da;

           pointer += Disasm((char*)pointer,MAXCMDSIZE,0x400000,&da,DISASM_SIZE);



       if(*(BYTE*)pointer == 0xC2 ) break;      // ret value

           else if(*(BYTE*)pointer == 0xC3 ) break; // ret

           else if(*(BYTE*)pointer == 0xCA ) break; // retf value

           else if(*(BYTE*)pointer == 0xCB ) break; // retf

       }



       DWORD length = pointer - ackData->MemoryCheck_function_adresses[i];



       if(length > 0) {

          unsigned char md5_buffer[16];

          md5_get_hshield(&md5_buffer[0], (BYTE*)ackData->MemoryCheck_function_adresses[i], length);

          md5_append_hshield(&state, &md5_buffer[0], 16);

       }



    }



    md5_finish_hshield(&state, &ackAnswer->MemoryCheck_checksum[0]);



    return 0;

}

int HackShieldEmu::GetIntegrityCheck1Data(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer)

{

    return GetCustumMD5OfFile("..\\checksum_files\\RagII.exe", ackData->IntegrityCheck1_offset_ragII_exe, ackData->IntegrityCheck1_size_ragII_exe, &ackAnswer->IntegrityCheck1_checksum[0]);

}

int HackShieldEmu::GetIntegrityCheck2Data(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer)

{

    md5_state_t state;

    md5_init(&state);



    unsigned char temp_md5[16];

      

    if(GetCustumMD5OfFile("..\\checksum_files\\Ehsvc.dll", 0, 0, &temp_md5[0])) return 1;

    md5_append_hshield(&state, &temp_md5[0], 16);



    if(GetCustumMD5OfFile("..\\checksum_files\\EGRNAP.dll", 0, 0, &temp_md5[0])) return 2;

    md5_append_hshield(&state, &temp_md5[0], 16);



    md5_finish_hshield(&state, &ackAnswer->IntegrityCheck2_checksum[0]);



    return 0;

}

int HackShieldEmu::GetIntegrityCheck3Data(hshield_packet_ack_server *ackData,hshield_packet_ack_client *ackAnswer)

{

    md5_state_t state;

    md5_init(&state);



    unsigned char temp_md5[16];

      

    if(GetCustumMD5OfFile("..\\checksum_files\\v3warpds.v3d", 0, 0, &temp_md5[0])) return 1;

    md5_append_hshield(&state, &temp_md5[0], 16);



    if(GetCustumMD5OfFile("..\\checksum_files\\v3warpns.v3d", 0, 0, &temp_md5[0])) return 2;

    md5_append_hshield(&state, &temp_md5[0], 16);



    md5_finish_hshield(&state, &ackAnswer->IntegrityCheck3_checksum[0]);



    return 0;

}





void HackShieldEmu::calculate_hshield_aeskey(unsigned char* input, unsigned char* output)

{

    unsigned char *temp = new unsigned char[20];

    memcpy(temp, input, 16);

   



    for(int i=0;i<5;i++)

    {

       md5_state_t state;

       md5_init(&state);

       md5_append_hshield(&state, temp, 16);

       md5_finish_hshield(&state, temp);

       for(int i=0; i<8;i++) temp[i] =  temp[i] ^ temp[i+8];

    }

   



    unsigned char *temp2 = new unsigned char[20];



    for(int i=0;i<4;i++)

    {

       DWORD *dtemp1 = (DWORD*)&temp[i*4];

       DWORD *dtemp2 = (DWORD*)&temp2[i*4];



       *dtemp2 =  *dtemp1 & 0xFFFF0000;



       *dtemp1 =  (*dtemp1 * 69069 ) + 1;



       *dtemp2 |= ( *dtemp1 & 0xFFFF0000 ) >> 16;

    }



    memcpy(output, temp2, 16);



    delete[] temp;

      delete[] temp2;



    for(int i=0; i < 16; i++)

    {

         if(output[i] & 1) output[i] ^= 0xDF ^ (output[i] >> 1);

         else output[i] ^= output[i] >> 1;

      }



}



int HackShieldEmu::encrypt_logfile_data(unsigned char *output, unsigned char *input, int sizeInput,DWORD key)

{



  if ( output && input && sizeOutput > 0 &&  sizeInput > 0 )

  {  

       

    memset(output, 0, sizeInput);

    

    if ( sizeInput > 0 )

    {   

      unsigned char *v8 = new unsigned char[4];

      DWORD *dword_v8 = (DWORD*)v8;

      *v8 = 0x00000000;

     

      unsigned char *temp_key = new unsigned char[4];

      DWORD *dword_temp_key = (DWORD*)temp_key;

      *dword_temp_key = key;



      for(int i = 0; i < sizeInput; i++)

      {

            v8[1] = temp_key[1] ^ input[i]; // encrypt the input byte

       

        output[i] = v8[1]; // write the encrypted input byte to the output

       

        *dword_v8 = 12691 * (*dword_temp_key + v8[1]); // update v8

       

        *dword_temp_key = 22719 - *dword_v8; // update tempkey

      }

         

      delete[] v8;

      delete[] temp_key;

    }

    return 0;

  }



  return -1;

}

int HackShieldEmu::decrypt_logfile_data(unsigned char *output, unsigned char *input, int sizeInput,DWORD key = 1252)

{



  if ( output && input && sizeOutput > 0 &&  sizeInput > 0 )

  {  

       

    memset(output, 0, sizeInput);

    

    if ( sizeInput > 0 )

    {   

      unsigned char *v8 = new unsigned char[4];

      DWORD *dword_v8 = (DWORD*)v8;

      *v8 = 0x00000000;

     

      unsigned char *temp_key = new unsigned char[4];

      DWORD *dword_temp_key = (DWORD*)temp_key;

      *dword_temp_key = key;



      for(int i = 0; i < sizeInput; i++)

      {

            v8[1] = temp_key[1] ^ input[i]; // encrypt the input byte

       

        output[i] = v8[1]; // write the encrypted input byte to the output

           

        *dword_v8 = 12691 * (*dword_temp_key + input[i]); // update v8

       

        *dword_temp_key = 22719 - *dword_v8; // update tempkey

   

      }

         

      delete[] v8;

      delete[] temp_key;

    }

    return 0;

  }



  return -1;

}

Basic project from a while back (No fix for MakeAckMsg and MakeGuidAckMsg)

2011-04-27T08:17:00.001-07:00

#include 
#include 
#include 

FILE*   Log   = 0;
unsigned long  Return   = 0;
void*   Service   = 0;

/*
EhSvc.dll Export Summary

 Export Args Type  Name
- 1  6  void  Initialize
- 2  0  int  StartService
- 3  0  int  StopService
- 4  0  void  Clear
- 5  0  void  Unknown
- 6  2  void  Unknown
- 7  0  int  Unknown
- 8  1  int  Unused
- 9  1  int  Unused
- 10  1  int  Initialize_2
- 11  ?  ?  Unknown
- 12  2  int  MakeAckMsg
- 13  2  int  MakeGuidAckMsg
- 14  2  void  SaveSafeFunc
- 15  3  int  Unused
- 16  3  int  Unused
*/

enum ShieldFunctions
{
 Shield_None,
 Shield_Initialize,
 Shield_StartService,
 Shield_StopService,
 Shield_Clear,
 Shield_Unknown01,
 Shield_Unknown02,
 Shield_Unknown03,
 Shield_Unused01,
 Shield_Unused02,
 Shield_Initialize_2,
 Shield_Unknown04,
 Shield_MakeAckMsg,
 Shield_MakeGuidAckMsg,
 Shield_SaveSafeFunc,
 Shield_Unused03,
 Shield_Unused04,
};

const char* ShieldNames[] =
{
 "Initialize",
 "StartService",
 "StopService",
 "Clear",
 "Unknown01",
 "Unknown02",
 "Unknown03",
 "Unused01",
 "Unused02",
 "Initialize_2",
 "Unknown04",
 "MakeAckMsg",
 "MakeGuidAckMsg",
 "SaveSafeFunc",
 "Unused03",
 "Unused04",
};

unsigned long HookJMP ( unsigned char* pbSource, unsigned char* pbDest )
{
 unsigned long dwOldMask;

 if ( VirtualProtect ( pbSource, 5, 0x40, &dwOldMask ) )
 {
  unsigned char* pbBuffer = (unsigned char*) malloc ( 10 );
  memcpy  ( pbBuffer, pbSource, 5 );
  pbBuffer += 5;

  pbBuffer [0] = 0xE9;
  pbSource [0] = 0xE9;

  *(unsigned long*)(pbBuffer + 1) = (unsigned long)( pbSource + 5 - pbBuffer ) - 5;
  *(unsigned long*)(pbSource + 1) = (unsigned long)( pbDest - pbSource )  - 5;

  VirtualProtect ( pbSource, 5, dwOldMask, &dwOldMask );
  return  (unsigned long) (pbBuffer - 5);
 }

 return 0;
}

unsigned long Real_CreateGUID  = 0;
int WINAPI Shield_CreateGUID ( char* BufferIn, char* BufferOut )
{
 _asm pushad

 fprintf ( Log, "B IN\t%i %s\nB OUT\t%i %s\n", strlen ( BufferIn ), BufferIn, strlen ( BufferOut ), BufferOut );
 fflush ( Log );

 _asm popad
 _asm push BufferOut
 _asm push BufferIn
 _asm call Real_CreateGUID
 _asm pushad

 fprintf ( Log, "A IN\t%i %s\nA OUT\t%i %s\n", strlen ( BufferIn ), BufferIn, strlen ( BufferOut ), BufferOut );
 fflush ( Log );

 _asm popad
}

__declspec ( naked ) void Shield_GenericBypass ( void )
{
 _asm pop Return
 _asm xor eax, eax
 _asm jmp Return
}

unsigned long pReal_GetProcAddress = 0;
FARPROC __stdcall GetProcAddress_Hook ( void* Module, int Function )
{
 FARPROC  Address = 0;

 _asm push Function
 _asm push Module
 _asm call pReal_GetProcAddress
 _asm mov Address, eax

 _asm pushad

 if ( Module == Service )
 {
  fprintf ( Log, "[HackedShield] Redirecting function %s\n", ShieldNames [Function - 1] );
  fflush ( Log );

  switch ( Function )
  {
  case Shield_MakeGuidAckMsg:
   Real_CreateGUID = (unsigned long) Address;
   Address  = (FARPROC) Shield_CreateGUID;
   break;

  default:
   Address = (FARPROC) Shield_GenericBypass;
   break;
  }
 }

 _asm popad

 return  Address;
}

unsigned long pReal_LoadLibrary = 0;
void* __stdcall LoadLibrary_Hook ( char* Module )
{
 void*  Handle = 0;

 _asm push Module
 _asm call pReal_LoadLibrary
 _asm mov Handle, eax

 _asm pushad

 if ( strstr ( Module, "EhSvc.dll" ) )
 {
  MessageBox ( 0, 0, 0, 0 );
  Service  = Handle;
 }

 _asm popad

 return  Handle;
}

int __stdcall DllMain ( HMODULE Dll, unsigned long Reason, void* Reserved )
{
 if ( Reason == 1 )
 {
  DWORD  Protect;
  char  LogPath  [MAX_PATH];

  GetModuleFileName  ( Dll, LogPath, sizeof ( LogPath ) );
  strcpy    ( &LogPath [strlen ( LogPath ) - 3], "log" );
  Log    = fopen ( LogPath, "w+" );

  HMODULE  Kernel  = GetModuleHandle ( "kernel32.dll" );
  pReal_LoadLibrary  = HookJMP ( (unsigned char*) GetProcAddress ( Kernel, "LoadLibraryA" ),  (unsigned char*) LoadLibrary_Hook );
  pReal_GetProcAddress  = HookJMP ( (unsigned char*) GetProcAddress ( Kernel, "GetProcAddress" ), (unsigned char*) GetProcAddress_Hook );
 }

 return 1;
}

StartServiceW

2011-04-27T08:12:00.001-07:00

#include 
#include 
#include 
#include 
#include 
#include 
#include "Hackshield.h"

typedef HANDLE (WINAPI* CreateFileA_t)(LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile);
typedef BOOL (WINAPI* DeviceIoControl_t)(HANDLE hDevice,DWORD dwIoControlCode,LPVOID lpInBuffer,DWORD nInBufferSize,LPVOID lpOutBuffer,DWORD nOutBufferSize,LPDWORD lpBytesReturned,LPOVERLAPPED lpOverlapped);
typedef BOOL (WINAPI* StartServiceW_t)(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCWSTR *lpServiceArgVectors);

HANDLE hEagle;
SC_HANDLE scEagle;
CreateFileA_t oCreateFileA;
DeviceIoControl_t oDeviceIoControl;
StartServiceW_t oStartServiceW;

bool FindModule(char* ModuleName, MODULEENTRY32& me32)
{
 HANDLE hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId());
 me32.dwSize = sizeof(MODULEENTRY32);

 for(BOOL Result = Module32First(hModuleSnap, &me32); Result != FALSE; Module32Next(hModuleSnap, &me32))
 {
  if(!strcmp(ModuleName, me32.szModule))
   return true;
 }

 return false;
}

//==============================================================
// hooked StartServiceW
//==============================================================
BOOL WINAPI hStartServiceW(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCWSTR *lpServiceArgVectors)
{
 MessageBox(0, "k", "k", 0);

 MODULEENTRY32 me32;
 if(FindModule("EhSvc.dll", me32))
 {
  DWORD RetnAddr = (DWORD)_ReturnAddress();
  if(RetnAddr > (DWORD)me32.modBaseAddr && RetnAddr < (DWORD)me32.modBaseAddr + me32.modBaseSize)
   return FALSE;
 }

 return oStartServiceW(hService, dwNumServiceArgs, lpServiceArgVectors);
}

//==============================================================
// hooked CreateFile
//==============================================================
HANDLE WINAPI hCreateFileA(LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile)
{
 /*
 if(!strcmp(lpFileName, "\\\\.\\EagleNT"))
 {
  hEagle = oCreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
  return hEagle;
 }
 */

 return oCreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
}

//==============================================================
// hooked DeviceIoControl
//==============================================================
BOOL WINAPI hDeviceIoControl(HANDLE hDevice,DWORD dwIoControlCode,LPVOID lpInBuffer,DWORD nInBufferSize,LPVOID lpOutBuffer,DWORD nOutBufferSize,LPDWORD lpBytesReturned,LPOVERLAPPED lpOverlapped)
{
 /*
 if(hDevice == hEagle)
  return TRUE;
 */

 return oDeviceIoControl(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
}

//==============================================================
// startup function for hackshield bypassing
//==============================================================
void Hackshield_Thread()
{
 CDetour dtDeviceIoControl;
 oDeviceIoControl = (DeviceIoControl_t)dtDeviceIoControl.SetupDetour(i368Jmp, (void*)GetProcAddress(GetModuleHandle("KERNEL32.DLL"), "DeviceIoControl"), &hDeviceIoControl);

 CDetour dtCreateFileA;
 oCreateFileA = (CreateFileA_t)dtCreateFileA.SetupDetour(i368Jmp, (void*)GetProcAddress(GetModuleHandle("KERNEL32.DLL"), "CreateFileA"), &hCreateFileA);

 CDetour dtStartServiceW;
 oStartServiceW = (StartServiceW_t)dtStartServiceW.SetupDetour(i368Jmp, (void*)GetProcAddress(GetModuleHandle("AdvApi32.dll"), "StartServiceW"), &hStartServiceW);
}

[TUTORIAL]how to fix your CRC with pictures :P

2011-04-27T08:04:00.001-07:00

First i would like to give credits to Obama for his lame tutorial :P but after an hour or so i figured it out, but to make it easier on others i decided to write a tut that is actualy easy to understand.

1. when there is a new update aviable ofcourse you have to update the game and unpack again (or so i think, dont judge id it can be one witohut unpacinkg again since i usualy use CE)

First we update CRC then unpack the data packs just to make it easier

open the BIN folder and delete

CRC folder
and
CRC text file

This image has been resized. Click this bar to view the full image. The original image is sized 812x662.

now start the game with the launcher as if you were hacking

Log in, and enter the game, then just click exit.

A new CRC folder and CRC text file will appear (updated)

Now unpack the data packs, after it is unpacked you should have a new folder called data (located in C:\Program Files\Acclaim\2MOONS\data\data)

Cut everything from inside of that data folder and paste it into 2moons data (where your data packs are, usualy (C:\Program Files\Acclaim\2MOONS\data)

you do not need to delete your data packs, only replace the original shadow file with the new one (links provided on the bottom) but just in case make a backup of your shadow file

Once you have done all that you have updatet CRC and you can login and play with unpacked data (which ofcourse you can edit with hacks that you want)

In case there is already a tutorial on how to update CRC accept my appologies and feel free to close this thread

Once again i would have not figured it out if there was not for Obama (no im not talking about US president)

Here is and already updated CRC (for .33) http://rapidshare.com/files/280152407/CRC.rar

and dekaron.exe if needed http://rapidshare.com/files/280159837/dekaron.rar

How to make a Combat Arms Bypass

2011-04-27T08:01:00.000-07:00

How to make a CA Bypass

OllyDbg (http://www.ollydbg.de/odbg110.zip
PE Explorer http://www.heaventools.com/download/pexsetup.exe
PEiD http://www.peid.info/files/PEiD-0.94-20060510.zip
CRC32 PEiD Plugin http://www.peid.info/plugins/crc32-gelios.zip

[Tutorial] Fix the CRC of changed files

2011-04-27T07:58:00.000-07:00

First of all, i havent tried this on the Dragonica files, but it worked in other games that are protected by GameGuard and HackShield Pro.

Hihow!
Again a trial on how to fix the CRC checksum of changed pe-files (exe & dll), as mentioned above, i havent tried it on Dragonica files but it should work.

What you need:

PEiD v0.95 -> Download
CRC32 Plugin by Gelios -> Download
Changed files ^^

Step-by-Step:

Unpack PEiD v0.95 anywhere on your Computer (e.g. Desktop)
Unpack the CRC32 Plugin into the Plugin Folder of PEiD
Start PEiD, click Options and make sure they are as folows:
Click Save and restart PEiD
Now open the ORIGINAL and UNCHANGED file in PEiD and click the Button named "->" (lower right corner of PEiD) choose Plugins->CRC32 and click it
Now you will see a window like this:
Copy the CRC32 value and close the Plugin window
Now open up the CHANGED file in PEiD and open the CRC32 Plugin window again
Now paste the CRC32 value from the original file into the "New CRC" field and click "Fix it!"
Now close the Plugin window and PEiD

é voila there you go the CRC is fixed and your changed file should work

Credits:

Step-by-Step Tutorial: eMale a.k.a LemoniscooL
Pictures: eMale a.k.a LemoniscooL
PEiD v0.95: Jibz, Qwerton, snaker, xineohP from PEiD
CRC32 Plugin for PEiD: Gelios

Crc-32

2011-04-27T07:55:00.001-07:00

"Crc-32"
by
Arturo San Emeterio Campos

Disclaimer
Copyright (c) Arturo San Emeterio Campos 1999. All rights reserved. Permission is granted to make verbatim copies of this document for private use only.

Download
Download the whole article zipped.

Table of contents

Contacting the author

Introduction
Here we are again, today let's talk about an interesting topic: Crc. I'll not deal with all the theory behind it, I'll only present the way of calculating the standard 'Crc 32 bits' that so many progams use (pkzip, arj...) If you want to learn why and how it works, have a look at one article by Ross Williams that is available at his home page . What's the use of a Crc? just to check if a file has been modified, it's used by most compressors and also by some anti-virus, it's used for error detection.

Crc-32
As we don't want to intrude a lot of redundancy (usually we don't want bigger files, but rather smaller ones) we keep a number and change it with every new byte processed, and luckily we do not produce two equal crc's (while this is possible, the probability is too low) so this value can represent the file.
Crc, Cyclic Redundancy Code. In this case we use a 32 bits value, a double word, also named unsigned long (in C). What we'll do is to keep a table of double words with 256 entries (exactly, one for every input byte), and xor the output value (the crc) with the value in the table, choosed xoring the input byte and Crc value, before xoring them you should shift to the right 8 times the Crc value. If the definition isn't clearer enough, look at the pseudo code.
Attached in the zip file there's the table for assembler (pc), and for C. In case you need, I can send it to you in binary form.
Before starting doing the whole process you should init the Crc value to 0FFFFFFFFh (the value used in this Crc) and when it's finished xor it with 0FFFFFFFFh. Once this is over this value is ready to be saved, along with the compressed data (in case of a compressor) then the decompressor decompress the data, calculates the Crc32 for this data, and if it's not equal to the Crc saved, then the Data is corrupted. (probably media error)

Pseudo Code
Here it is the pseudo code for doing it:

Crc_value = 0FFFFFFFFh
Loop (for all the bytes in input)

Position = (byte_from_input XOR Crc_value) AND 0FFh
Table_value = Crc32_table[position]
Crc_value = Crc_value >> 8
Crc_value = Crc_Value XOR table_value

Crc_value = Crc_value XOR 0FFFFFFFFh

Note that we AND the result from the xor with the input byte and Crc values, because we only want values beetwen 0-255. Remember that Crc_value and table_value are both dwords. In the case you use it with a decompressor, you may want to compute the crc for every byte as soon as it's decoded. (to avoid to do a second pass to compute the crc)
Checking the check
The example from Ross Williams's guide: the string "123456789" should produce a Crc value of: CBF43926h
The include (asm version) with the table has a Crc value of: 4611B565h. If you want more examples just get winzip and read the Crc of some files and compare it with the result of your implementation.

Closing words
If you can't get it to work, you can get a C implementation at Crblib, by Charles Bloom. And if you want to learn more about crc's, you are encouraged to read "A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS" by Ross N. Williams, available at his home page.

Contacting the author
You can reach me via email at: arturo@arturocampos.com Also don't forget to visit my home page http://www.arturocampos.com where you can find more and better info. See you in the next article!

Arturo San Emeterio Campos, Barcelona 10-Aug-1999