Solución al reverseme! de Victor
Hola!,
Ahora que alguien ya ha resuelto el reverseme! de Victor, enhorabuena a Tora y a Miguel : dice erg0t que eres una VM humana! ;-), aprovecho para postear mi solución, con código fuente incluido :-).
Lo primero era echar un vistazo al reverseme! de Victor y ver que perrerías nos había puesto, después de pasar su algoritmo a C, con un poquito de asm inline para ver el estado de la FPU 😉 , nos quedamos con algo como lo siguiente …
#include <stdio.h>
#include <math.h>
const float _f_1 = 3.2e2;
const float _f_2 = 5.96e2;
const float _f_3 = 8.8804e4;
const double _d_1 = 1.0e2;
const double _d_2 = 4.0e2;
const double _d_3 = 1.0;
int main (int argc, char **argv )
{
double r,r1,r2;
float s1,s2;
int bdiverror = 0;
// get_right_values(&s1,&s2);
printf("Trying values … : %f-%fn",s1,s2);
r = ( ( s1 – _f_1 ) * (s1 – _f_1) ) / _d_1;
r1 = ( ((s2 * s2) – (_f_2 * s2)) + _f_3 ) / _d_2 ;
if ( (r + r1) == _d_3)
{
r2 = log(s1 / s2);
// By default FP exceptions are not enabled so
// we just check FP status for divide error 🙂
__asm
{
fld r2
fdivr _d_3
fnstsw ax
test ax, 4
jz noerror
mov bdiverror, 1
noerror:
}
// In order to raise a divide error (right password) we need r2 to be 0,
}
if (bdiverror)
{
printf("Right!!n");
}
else
{
printf("Wrong!!n");
}
}
Bien, parece que victor nos ha planteado un sistema formado por las siguientes ecuaciones :
a) ln(x/y) = 0;
b) ( ( ( x – _f_1 ) ^ 2 ) / _d_1 ) + ( ( y^2 – _f_2 * y + _f_3 ) / _d_2 ) = 1
De la primera ecuación podemos inferir lo siguiente :
ln(x/y) = 0 => (x/y) = 1 => x = y
Por lo tanto pasamos a sustituir todas las x por y en la segunda ecuación :
( (x – _f_1) ^2 ) / _d_1 ) + ( (x^2 – _f_2 * x + _f_3) /_d_2) = 1
Y desarrollamos :
_d_2 ( x^2 + _f_1^2 – 2 * _f_1 * x ) + _d_1 ( x^2 – _f_2 * x + _f_3 ) = _d_1 * _d_2
( _d_2 + _d_1 ) x^2 + ( – 2 * _f_1 * _d_2 – _d_1 * _f_2 ) * x + ( _d_2 * _f_1^2 + _d_1 * _f_3 – _d_1 * _d_2 )
Con esta expresión ya podemos escribir una pequeña función que resuelva la ecuación de segundo grado en dependencia de las constantes que ha puesto Victor :
{
float a,b,c;
// Usamos los valores obtenidos en el desarrollo :
a = (float) (_d_2 + _d_1);
b = (float) ( -2 * _f_1 * _d_2 – _d_1 * _f_2 );
c = (float) ( _d_2 * _f_1 * _f_1 + _d_1 * _f_3 – _d_1 * _d_2 );
// Calculamos una de las posibles raices de la ecuación.
*s1 = ( -b – sqrtf(b*b – 4 * a * c) ) / (2*a);
// El otro término debe ser igual
*s2 = *s1;
}
Añadimos esta función al codigo revertido de Victor y ejecutamos nuestro programa …
Trying values … : 314.000000-314.000000
Right!!
Si probamos estos valores con el binario original de Victor también funcionan 😉 , el código
fuente de todo esto lo podeís encontrar aquí.
Gracias por el interesante reverseme! Victor, mira a ver si te curras otro 😀
Un saludo,
Mario