/*
   Solucion al reverseme! de Victor
   --

   Después de analizar el fichero con ayuda del magnífico IDA, 
   vemos que el problema de Victor hace lo que se ve a continuación,
   la implementación de la solución está en la función get_right_values, 
   por lo tanto esta se debe obviar :-), al final del fichero se puede
   ver como se ha llegado a la solución.

   Mario Ballano 24/7/2007

*/


#include <stdio.h>
#include <math.h>
#include <Windows.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;	

void get_right_values (float *s1, float *s2)
{
	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;
}


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-%f\n",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 (i.e right password) we need r2 to be 0,						

	}

	if (bdiverror)
	{
		printf("Right!!\n");
	}
	
	else
	{
		printf("Wrong!!\n");
	}

}


/*


   * Tenemos que resolver el siguiente sistema de 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 ecuación a) inferimos : 

     ln(x/y) = 0  =>  (x/y) = 1  =>  x = y 

   * Sabiendo esto, sustituimos todas las y por x en la ecuación a : 

	(x - _f_1) ^2         x^2 - _f_2 * x + _f_3
	--------------    +   ---------------------   = 1
          d1                      d2

    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 )

	Y ya podemos resolver la ecuación de segundo grado por la formula tradicional en el codigo :-)

*/