Foro de elhacker.net

Buenas a todos

A ver, no estoy acostumbrado a trabajar con ASM y tengo una duda que no puedo resolver xD

Estoy trabajando con una variable de tiplo single (float) y he llegado a la instrucción que modifica dicha variable:

fadd qword ptr [Project1.exe+10A0]
fstp dword ptr [esi+34]

La primera instrucción me añade (fadd) el valor de Project1.exe+10A0 (que tiene un valor de 0.25). Luego la segunda instrucción almacena el valor en la variable esi+34 ¿lo digo bien? Bueno, pues yo quiero aumentar 0.75 en lugar de 0.25, he probado lo siguiente:

fadd qword ptr [0.75] = Ya se que eso no funciona, pero tenía que probarlo
fadd qword ptr 0.75 = Tampoco funciona
mov [esi+34],0.75 = Tampoco funciona

Como podéis observar, lo estoy haciendo fatal, jaja. Cual es la instrucción que me permite añadir el valor que yo quiera a mi variable de tiplo Single (float)?

Saludos y gracias

Para cargar valores en el registro tienes que usar la instruccion fld, si te fijas tienes instrucciones como fld1, fldz.

No se si te refieres a eso.

Un saludo.

Edito:

Si tienes 0.25 en el registro, 0x3e800000, i quieres que tenga el valor de 0.75, puedes cargarlo como te dijo con fld o sumarle con fadd.

pushq $0x3f000000 ; 0.50
fadd (%rsp)
fst (%rsp)

Ahora tendrias 0x3f400000, 0.75 cargado en la pila.

Tambien con fld.

fldz   ; registro a zero
pushq $0x3f400000
fld (%rsp)

Ya tendrias 0.75 cargado.

Gracias por responder, me ha servido tu explicación de fldz para poner el registro a zero.

Ahora lo que he conseguido es nopear la instrucción fadd y he hecho lo siguiente:

mov [esi+34],3F800000

Con eso, establezco el valor de la variable a 1 (que también me interesa hacerlo).

Ahora solo quiero aprender como funcionan los números decimales en ASM. No entiendo porque 1 = 3F800000 y el 2 = 40000000

Hay alguna tabla que me permita calcular el valor hexadecimal de un número decimal (float)?

De nada, pero que quieres hacer? No es mejor utilizar fld1? para que utilizas la pila.

Utiliza los registros st, no la pila, estara mucho mejor, si me dices que estas haciendo, te dejo un ejemplo.


En alguna parte lei la explicacion de todo esto, pero ya no tengo el documento....

Pero de momento puedes ayudarte con un conversor de numeros decimales a hex.

Un saludo.

P.D: Haz lo que pretendas a tu manera, y yo intentare mejorarlo, si quieres.

Estoy haciendo trainers para un videojuego (cheats, trucos, etc), utilizo CheatEngine + inyección de codigo.

La variable que pretendo modificar es de tipo Float (hay otras Double, pero es casi lo mismo). El código original resta 0.25 en cada ejecición y yo quiero que se almacene el valor 100 en lugar de restar, es decir:

A = A - 0.25 (éste el el código original)

Y lo que quiero hacer yo es:

A = A - 0.25
A = 100 (Añadir ésta línea para que mi variable tenga el valor de 100 todo el rato)

Vale, ahora entiendo porque utilizas la pila, pensaba que era para hacer algun tipo de calculo matematico, por eso te dije los de los registros.

Porque es mejor hacer esto:

fld1

Que no esto:

movl 0x3f800000, 34(%esi)
fld 34(%esi)

Pero para lo que pretendes creo que bastaria moviendo o sumando con fadd 0x42c80000 100.0, a la variable, si tienes alguna duda ya sabes.

Un saludo.

Duda ninguna, me lo has explicado todo perfecto. Solo falta entender como coño funcionan los numeros decimales en asm (hexadecimal), por mas que lo smiro, no les veo ninguna lógica o relación xD

Los numeros enteros y los negativos si que los entendí, pero los decimales..... es dificil ver que 0x42c80000 es 100 xD


edit, me ha ayudado mucho éste anexo: http://es.wikipedia.org/wiki/Anexo:Listados_de_instrucciones_x86

El estandar es el IEEE 754, pero ya no tengo la documentacion. Por cierto, aplicaste lo que te dije al trainer y funciona?

Un saludo.

Edito:

Los manuales de intel estan mejor que la wikipedia xD.

Lo he puesto a mi manera:

fstp dword ptr [esi+34]
mov [esi+34],42C80000
fnstsw ax

Así, al ejecutar la instrucción, la variable esi+34 siempre tendrá valor 100.0

 ;-)

Bien, copias el valor del registro st(0) a la pila, y luego dejas st(0) a su valor anterior, pero no entiendo el mov, porque mueves el valor del registro st(0) y luego reescribes el valor de la pila con el mov?

No es mejor hacer el mov directamente.

Y sobre fnstsw, luego comparas el valor para saber como esta el estado?

Un saludo.

El código original es:

Project1.exe+1CF0 - D9 46 34              - fld dword ptr [esi+34]
Project1.exe+1CF3 - DC 05 90104000        - fadd qword ptr [Project1.exe+1090]
Project1.exe+1CF9 - D9 5E 34              - fstp dword ptr [esi+34]
Project1.exe+1CFC - DFE0                  - fnstsw ax
Project1.exe+1CFE - A8 0D                 - test al,0D
Project1.exe+1D00 - 75 26                 - jne Project1.exe+1D28
Project1.exe+1D02 - C7 45 FC 00000000     - mov [ebp-04],00000000
Project1.exe+1D09 - 8B 45 08              - mov eax,[ebp+08]
Project1.exe+1D0C - 50                    - push eax
Project1.exe+1D0D - 8B 10                 - mov edx,[eax]
Project1.exe+1D0F - FF 52 08              - call dword ptr [edx+08]
Project1.exe+1D12 - 8B 45 FC              - mov eax,[ebp-04]
Project1.exe+1D15 - 8B 4D EC              - mov ecx,[ebp-14]
Project1.exe+1D18 - 5F                    - pop edi
Project1.exe+1D19 - 5E                    - pop esi
Project1.exe+1D1A - 64 89 0D 00000000     - mov fs:[00000000],ecx
Project1.exe+1D21 - 5B                    - pop ebx
Project1.exe+1D22 - 8B E5                 - mov esp,ebp
Project1.exe+1D24 - 5D                    - pop ebp
Project1.exe+1D25 - C2 0400               - ret 0004
Project1.exe+1D28 - E9 9FF3FFFF           - jmp Project1.exe+10CC

Yo lo que hago es inyectar (añadir una sola instrucción) en la cuarta línea:

Project1.exe+1CF0 - D9 46 34              - fld dword ptr [esi+34]
Project1.exe+1CF3 - DC 05 90104000        - fadd qword ptr [Project1.exe+1090]
Project1.exe+1CF9 - D9 5E 34              - fstp dword ptr [esi+34]
                                                        mov [esi+34],42C80000
Project1.exe+1CFC - DFE0                  - fnstsw ax
Project1.exe+1CFE - A8 0D                 - test al,0D
Project1.exe+1D00 - 75 26                 - jne Project1.exe+1D28
Project1.exe+1D02 - C7 45 FC 00000000     - mov [ebp-04],00000000
Project1.exe+1D09 - 8B 45 08              - mov eax,[ebp+08]
Project1.exe+1D0C - 50                    - push eax
Project1.exe+1D0D - 8B 10                 - mov edx,[eax]
Project1.exe+1D0F - FF 52 08              - call dword ptr [edx+08]
Project1.exe+1D12 - 8B 45 FC              - mov eax,[ebp-04]
Project1.exe+1D15 - 8B 4D EC              - mov ecx,[ebp-14]
Project1.exe+1D18 - 5F                    - pop edi
Project1.exe+1D19 - 5E                    - pop esi
Project1.exe+1D1A - 64 89 0D 00000000     - mov fs:[00000000],ecx
Project1.exe+1D21 - 5B                    - pop ebx
Project1.exe+1D22 - 8B E5                 - mov esp,ebp
Project1.exe+1D24 - 5D                    - pop ebp
Project1.exe+1D25 - C2 0400               - ret 0004
Project1.exe+1D28 - E9 9FF3FFFF           - jmp Project1.exe+10CC

La idea es modificar lo menos posible el código original. Dicha modificación se efectua en tiempo de ejecución (con WriteProcessMemory) y cuanto menos se modifique la imagen del ejecutable en runtime, mejor xD El fin de todo ésto es conseguir que la variable valga 100 al ejecutar ese código, así con un simple mov lo soluciono, es cierto que la instrucción anterior se podría quitar, pero mejor no tocar el código original ya que si quiero volver a dejar la función original, solo tendré que nopear el mov que he inyectado yo.

Es un poco enrevesado, pero a la hora de programar trainers es mejor hacerlo así.

Bien, no se nada sobre los trainers, pero esas instrucciones son inutiles, pero si es mejor pues bien para ti, bueno solo dire que a ver quien se atreve a jugar una partida contigo al call of duty ese xD.

Un saludo.