Páginas

anun1

miércoles, 21 de octubre de 2026

Solucion al Crackme GeckoAcademy 2026

Hola amigos hoy no puedo explicar el reto, ya que no tengo tiempo por mi trabajo, pero les dejo el generador de claves y el código del brute force del nivel 4 buenos este es el reto

Como podemos ver dice que tiene 4 niveles así que aquí les dejo el código del generador de claves en JavaScript y HTML para los primeros 3 niveles, otra cosa el nombre que usas en el primer nivel se usara en el tercero

<html>
<head>
<title>Keygen Reto GeckoAcademy 2026 ...:::Flamer:::...</title>
</head>
<body bgcolor="black">
<center>
<marquee style="font-size:30;color:yellow;">Keygen Reto GeckoAcademy 2026   ...:::By Flamer:::...</marquee><br><br>
<label style="color:white;">Nombre:</label>
<input type="text" id="nom" size='50' style="background-color:Gray;color:white;text-align:center;">
<input type="button" value="Copy" onclick="copiar1()"><br><br>
<label style="color:white;">Serial Nivel 1:</label>
<input type="text" id="pass1" size='80' style="background-color:Gray;color:white;text-align:center;">
<input type="button" value="Copy" onclick="copiar2()"><br><br>
<label style="color:white;">Serial Nivel 2:</label>
<input type="text" id="pass2" size='80' style="background-color:Gray;color:white;text-align:center;">
<input type="button" value="Copy" onclick="copiar3()"><br><br>
<label style="color:white;">Serial Nivel 3:</label>
<input type="text" id="pass3" size='80' style="background-color:Gray;color:white;text-align:center;">
<input type="button" value="Copy" onclick="copiar4()"><br><br>
<input type="button"  value="Generar" onclick="genera()" id="boton1">
</center>
<script>
function copiar1() 
{
   let c=document.getElementById('nom'); 
   navigator.clipboard.writeText(c.value);
}
//==================================================================================
function copiar2() 
{
   let c=document.getElementById('pass1'); 
   navigator.clipboard.writeText(c.value);
}
//==================================================================================
function copiar3() 
{
   let c=document.getElementById('pass2'); 
   navigator.clipboard.writeText(c.value);
}
//==================================================================================
function copiar4() 
{
   let c=document.getElementById('pass3'); 
   navigator.clipboard.writeText(c.value);
}
//==================================================================================
function genera()
{ 
//===========AQUI EMPIEZA EL DEL NIVEL 1=======================================================================
   let nombre=document.getElementById("nom").value;
   alert("El Mismo Nombre Ingresado Se Usara En El Nivel 3 y Tiene Que Ser Igual o Mayor a 5 Digitos...");
   let x,digi,edx=0,suma=0,clave,eax,ebx;
   if(nombre.length>4)
   {
      for(x=0;x<nombre.length;x++)
      {
         digi=nombre[x].charCodeAt(0);
	 edx=edx+1;
	 eax=edx * digi;
	 suma+=eax;
      }
      suma=suma ^ 3221340382;
      suma = (suma << 5) | (suma >>> 27);
      clave=suma.toString(16);
      clave=clave.toUpperCase();
   
      while(clave.length<8)
      {
         clave="0" + clave;
      }
      document.getElementById("pass1").value=clave;
//===========AQUI EMPIEZA EL DEL NIVEL 2=======================================================================
  
     let c1=calcula(4660,nombre),c2=calcula(43981,nombre),c3=calcula(30583,nombre);
     let c4= c1 ^ c2 ^ c3;
     let p1=c1.toString(16),p2=c2.toString(16),p3=c3.toString(16),p4=c4.toString(16);
   
     document.getElementById("pass2").value=p1.toUpperCase() + "-" + p2.toUpperCase() + "-" + p3.toUpperCase() + "-" + p4.toUpperCase();
//===========AQUI EMPIEZA EL DEL NIVEL 3=======================================================================  
    eax=5381;
    for(x=0;x<nombre.length;x++)
    {
       edx=eax<<5;
       edx=edx+eax;
       digi=nombre[x].charCodeAt(0);
       eax=digi ^ edx; 
    }
    let aa=new Array(19,55,192,255,238,66,153,1);
    for(x=0;x<aa.length;x++)
    {
       eax=eax ^ aa[x];
       if(eax<0)
       {
          eax=4294967296 + eax;
       }
       eax =rol32(eax,7);
       eax=eax - 1640531527;
       ebx = eax >>> 13;
       eax=eax ^ ebx;
       if(eax<0)
       {
          eax=4294967296 + eax;
       }
    }
    ebx=eax;
    eax=eax ^ 3737181905;
   
    if(eax<0)
    {
       eax=4294967296 + eax;
    }
   
    eax=rol32(eax,11);
    digi=eax.toString(16);
    while(digi.length<8)
    {
       digi="0" + digi;
    }
    document.getElementById("pass3").value=ebx.toString(16).toUpperCase() + digi.toUpperCase();
  }
  else
  {
     alert("El Nombre Debe Ser Igual o Mayor a 5 Digitos...");
  }
}
//==================================================================================
function rol32(value, shift)
{
    let a=(value << shift) | (value >>> (32 - shift));
    if(a<0)
    {
       a=4294967296 + a;
    }
    return a; 
}
//==================================================================================
function calcula(eax,nom)
{
   let digi,ebx,edx;
   for(x=0;x<nom.length;x++)
    {
      digi=nom[x].charCodeAt(0);
      eax=digi ^ eax;
      eax=eax * 40503;
      eax=cortar(eax);
      ebx=eax <<3;
      edx=eax >> 13;
      eax=ebx | edx;
      eax=cortar(eax);
    }
	
    return eax;
}
//==================================================================================
function cortar(n)
{
   let d;
   d=n.toString(16);
   d=d.slice(-4);
   n=parseInt(d,16);
   
   return n;
}
</script>
</body>
</html>

Aqui una foto


Ahora para pasar el nivel 4 usaremos el siguiente código

<html>
<head>
<title>Brute Force Nivel 4 De Reto GeckoAcademy 2026</title>
<body>
<center>
<input type="button" value="Digito 1" onclick="brute(0)">
<input type="button" value="Digito 2" onclick="brute(1)">
<input type="button" value="Digito 3" onclick="brute(2)">
<input type="button" value="Digito 4" onclick="brute(3)">
<input type="button" value="Digito 5" onclick="brute(4)">
<input type="button" value="Digito 6" onclick="brute(5)">
<input type="button" value="Digito 7" onclick="brute(6)">
<input type="button" value="Digito 8" onclick="brute(7)">
<input type="button" value="Digito 9" onclick="brute(8)">
<input type="button" value="Digito 10" onclick="brute(9)">
<input type="button" value="Digito 11" onclick="brute(10)">
<input type="button" value="Digito 12" onclick="brute(11)">
<br><br>
<input type="text" id="nom" value="ZZZZZZZZZZZZ" maxlength=12><br><br>
Resultado Del Serial Mas Cercano a 71EB175B<br>
<input type="text" id="log" size="50" style="text-align:center;"><br><br>
<textarea id="res" rows="30" cols="50"></textarea>
</center>
<script>
function calcula(pass) //pass
{
   let suma =5381,xore=256;
   let largo=pass.length;
   let x,digi;
   
   for(x=0;x<pass.length;x++)
   {
      suma = (suma << 5) | (suma >>> (32 - 5));
      if(suma<0)
      {
	      suma=4294967296 + suma;
      }	   
      digi=pass[x].charCodeAt(0);
      suma=suma+digi;
      suma=suma ^ xore;
      if(suma<0)
      {
	 suma=4294967296 + suma;
      }	
      xore++;
   }	
   suma=suma ^ 3405691582;
   if(suma<0)
   {
      suma=4294967296 + suma;
   }	  
   if(suma.toString(16).toUpperCase()=="71EB175B")
   {
      alert("Son iguales...");
   }
   document.getElementById("log").value=pass + "----->" + suma.toString(16).toUpperCase();
   return suma;
}
function brute(p)
{
    const Symbols ="!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"; 
        
    let pass=document.getElementById("nom").value;
	let x,abajo=0,actual,arriba=4294967296,up="",down="";	
	for(x=0;x<Symbols.length;x++)
	{
	    pass = pass.substring(0, p) + Symbols[x] + pass.substring(p + 1);
		actual=calcula(pass);
		if(actual==1911232347)
		{
		   break;
		}
		if(actual<1911232347) //71EB175B
		{
		   if(actual>abajo)
		   {
		      abajo=actual;
		      down=pass;
		   }
		}
		if(actual>1911232347)
		{
		   if(actual<arriba)
		   {
		      arriba=actual;
		     up=pass;
		   }
		}
	}
    document.getElementById("res").value="Por arriba--->" + arriba.toString(16).toUpperCase() + "-----Serial: " + up + "\n\nPor abajo--->" + abajo.toString(16).toUpperCase() + "-----Serial: " + down;		
}
</script>
</body>
</html>

Aqui una foto


Solo presionan el botón del dígito y en el campo de texto les aparecerá el serial que más se acerca por arriba y por debajo y después copean ese serial y lo ponen en el campo de texto serial y vuelven a presionar los botones de los dígitos yo encontré estos 2 seriales... Nota: hay más, pero yo me conforme con estos 2

Z(_ZZZ8ZZZtZ

VY6Co;YMYYYY

bueno saludos Flamer y espero les halla gustado


=======================EDITO==========================

Bueno para no borrar lo de arriba les explicó un poco que hace el programa, creí que no iba a tener tiempo por eso hice lo de arriba bueno vamos por parte primero abrimos el reto con el x64dbg y buscamos las string y vemos que pide un nombre y un serial de 8 dígitos así que buscamos los string esos en el programa y vemos lo siguiente


Así que damos clic en la línea seleccionada en la imagen y nos manda a esta zona, yo como nombre ingrese "polon" y como serial de 8 dígitos "33333333"


Así que revise los CALL de abajo y me encontré que donde se genera el serial está en el CALL que tiene el breakpoint y entramos en F7, pero aquí les dejo el código que es lo que hace

00007FF60BB11818 | 48:89C1                  | mov rcx,rax                                            |
00007FF60BB1181B | E8 10E20000              | call <JMP.&strlen>                                     |
00007FF60BB11820 | 48:8945 E8               | mov qword ptr ss:[rbp-18],rax                          |
00007FF60BB11824 | 48:C745 F0 00000000      | mov qword ptr ss:[rbp-10],0                            |
00007FF60BB1182C | EB 23                    | jmp geckoacademy2026_7_challenge.7FF60BB11851          |
00007FF60BB1182E | 48:8B55 10               | mov rdx,qword ptr ss:[rbp+10]                          | [rbp+10]:"polon"
00007FF60BB11832 | 48:8B45 F0               | mov rax,qword ptr ss:[rbp-10]                          |
00007FF60BB11836 | 48:01D0                  | add rax,rdx                                            |
00007FF60BB11839 | 0FB600                   | movzx eax,byte ptr ds:[rax]                            |
00007FF60BB1183C | 0FB6C0                   | movzx eax,al                                           |
00007FF60BB1183F | 48:8B55 F0               | mov rdx,qword ptr ss:[rbp-10]                          |
00007FF60BB11843 | 83C2 01                  | add edx,1                                              |
00007FF60BB11846 | 0FAFC2                   | imul eax,edx                                           |
00007FF60BB11849 | 0145 FC                  | add dword ptr ss:[rbp-4],eax                           |
00007FF60BB1184C | 48:8345 F0 01            | add qword ptr ss:[rbp-10],1                            |
00007FF60BB11851 | 48:8B45 F0               | mov rax,qword ptr ss:[rbp-10]                          |
00007FF60BB11855 | 48:3B45 E8               | cmp rax,qword ptr ss:[rbp-18]                          |
00007FF60BB11859 | 72 D3                    | jb geckoacademy2026_7_challenge.7FF60BB1182E           |
00007FF60BB1185B | 8175 FC DEC001C0         | xor dword ptr ss:[rbp-4],C001C0DE                      |
00007FF60BB11862 | 8B45 FC                  | mov eax,dword ptr ss:[rbp-4]                           |
00007FF60BB11865 | BA 05000000              | mov edx,5                                              |
 
Bueno me da peresa explicar linea por linea que es lo que hace asi que aqui les dejo el codigo en javascript

for(x=0;x<nombre.length;x++)
{
   digi=nombre[x].charCodeAt(0);
   edx=edx+1;
   eax=edx * digi;
   suma+=eax;
}
suma=suma ^ 3221340382;
suma = (suma << 5) | (suma >>> 27);

como ven al salir del ciclo xorea por 3221340382 y luego en el CALL siguiente hace un rol con 5 el resultado que dio del xoreo 


por ultimo compara el resultado del rol con el serial de 8 digitos que ingresamos



Bueno ahora nos vamos al nivel 2 y vemos que nos pide un solo serial y está dividido en 4 partes



Así que nos vamos a los string y buscamos el mensaje incorrecto del segundo nivel este


Damos clic en el y nos manda a esta zona


Así que revisaremos el CALL que tiene el breakpoint, ya que podemos ver que está el menaje correcto y el incorrecto y entramos con F7 y vemos lo siguiente.


Como observan están 3 CALL que mandan llamar a la misma función e ingresan valores diferentes que son en hexadecimal el 1234, el ABCD y el 7777 mas el mismo nombre que ingresamos en el primer nivel... Por último al salir de esos CALL xorea los mismos valores obtenidos para obtener el 4 valor  y despues los compara con el serial que ingresamos y si se preguntan que hacen esos CALL aquí les dejo el código en  ASM y la versión en JavaScript

00007FF60B1719B1 | 55                       | push rbp                                               |
00007FF60B1719B2 | 48:89E5                  | mov rbp,rsp                                            |
00007FF60B1719B5 | 48:83EC 40               | sub rsp,40                                             |
00007FF60B1719B9 | 48:894D 10               | mov qword ptr ss:[rbp+10],rcx                          | [rbp+10]:"polon"
00007FF60B1719BD | 89D0                     | mov eax,edx                                            |
00007FF60B1719BF | 66:8945 18               | mov word ptr ss:[rbp+18],ax                            |
00007FF60B1719C3 | 0FB745 18                | movzx eax,word ptr ss:[rbp+18]                         |
00007FF60B1719C7 | 66:8945 FE               | mov word ptr ss:[rbp-2],ax                             |
00007FF60B1719CB | 48:8B45 10               | mov rax,qword ptr ss:[rbp+10]                          | [rbp+10]:"polon"
00007FF60B1719CF | 48:89C1                  | mov rcx,rax                                            |
00007FF60B1719D2 | E8 59E00000              | call <JMP.&strlen>                                     |
00007FF60B1719D7 | 48:8945 E8               | mov qword ptr ss:[rbp-18],rax                          |
00007FF60B1719DB | 48:C745 F0 00000000      | mov qword ptr ss:[rbp-10],0                            |
00007FF60B1719E3 | EB 3B                    | jmp geckoacademy2026_7_challenge.7FF60B171A20          |
00007FF60B1719E5 | 48:8B55 10               | mov rdx,qword ptr ss:[rbp+10]                          | [rbp+10]:"polon"
00007FF60B1719E9 | 48:8B45 F0               | mov rax,qword ptr ss:[rbp-10]                          |
00007FF60B1719ED | 48:01D0                  | add rax,rdx                                            |
00007FF60B1719F0 | 0FB600                   | movzx eax,byte ptr ds:[rax]                            |
00007FF60B1719F3 | 0FB6C0                   | movzx eax,al                                           |
00007FF60B1719F6 | 66:3145 FE               | xor word ptr ss:[rbp-2],ax                             |
00007FF60B1719FA | 0FB745 FE                | movzx eax,word ptr ss:[rbp-2]                          |
00007FF60B1719FE | 66:69C0 379E             | imul ax,ax,9E37                                        |
00007FF60B171A03 | 66:8945 FE               | mov word ptr ss:[rbp-2],ax                             |
00007FF60B171A07 | 0FB745 FE                | movzx eax,word ptr ss:[rbp-2]                          |
00007FF60B171A0B | BA 03000000              | mov edx,3                                              |
00007FF60B171A10 | 89C1                     | mov ecx,eax                                            |
00007FF60B171A12 | E8 85FAFFFF              | call geckoacademy2026_7_challenge.7FF60B17149C         |
00007FF60B171A17 | 66:8945 FE               | mov word ptr ss:[rbp-2],ax                             |
00007FF60B171A1B | 48:8345 F0 01            | add qword ptr ss:[rbp-10],1                            |
00007FF60B171A20 | 48:8B45 F0               | mov rax,qword ptr ss:[rbp-10]                          |
00007FF60B171A24 | 48:3B45 E8               | cmp rax,qword ptr ss:[rbp-18]                          |
00007FF60B171A28 | 72 BB                    | jb geckoacademy2026_7_challenge.7FF60B1719E5           |
00007FF60B171A2A | 0FB745 FE                | movzx eax,word ptr ss:[rbp-2]                          |
00007FF60B171A2E | 48:83C4 40               | add rsp,40                                             |
00007FF60B171A32 | 5D                       | pop rbp                                                |
00007FF60B171A33 | C3                       | ret                                                    |


Y el CALL que esta adentro de esta función, que es la que hace desplazamientos de bits

00007FF60B17149C | 55                       | push rbp                                               |
00007FF60B17149D | 48:89E5                  | mov rbp,rsp                                            |
00007FF60B1714A0 | 89C8                     | mov eax,ecx                                            |
00007FF60B1714A2 | 8955 18                  | mov dword ptr ss:[rbp+18],edx                          |
00007FF60B1714A5 | 66:8945 10               | mov word ptr ss:[rbp+10],ax                            |
00007FF60B1714A9 | 8365 18 0F               | and dword ptr ss:[rbp+18],F                            |
00007FF60B1714AD | 0FB755 10                | movzx edx,word ptr ss:[rbp+10]                         |
00007FF60B1714B1 | 8B45 18                  | mov eax,dword ptr ss:[rbp+18]                          |
00007FF60B1714B4 | 89C1                     | mov ecx,eax                                            |
00007FF60B1714B6 | D3E2                     | shl edx,cl                                             |
00007FF60B1714B8 | 89D0                     | mov eax,edx                                            |
00007FF60B1714BA | 41:89C0                  | mov r8d,eax                                            |
00007FF60B1714BD | 0FB755 10                | movzx edx,word ptr ss:[rbp+10]                         |
00007FF60B1714C1 | B8 10000000              | mov eax,10                                             |
00007FF60B1714C6 | 2B45 18                  | sub eax,dword ptr ss:[rbp+18]                          |
00007FF60B1714C9 | 89C1                     | mov ecx,eax                                            |
00007FF60B1714CB | D3FA                     | sar edx,cl                                             |
00007FF60B1714CD | 89D0                     | mov eax,edx                                            |
00007FF60B1714CF | 44:09C0                  | or eax,r8d                                             |
00007FF60B1714D2 | 5D                       | pop rbp                                                |
00007FF60B1714D3 | C3                       | ret                                                    |

Aquí su versión en JavaScript

let c1=calcula(4660,nombre),c2=calcula(43981,nombre),c3=calcula(30583,nombre);
let c4= c1 ^ c2 ^ c3;

function calcula(eax,nom)
{
   let digi,ebx,edx;
   for(x=0;x<nom.length;x++)
    {
      digi=nom[x].charCodeAt(0);
      eax=digi ^ eax;
      eax=eax * 40503;
      eax=cortar(eax);
      ebx=eax <<3;
      edx=eax >> 13;
      eax=ebx | edx;
      eax=cortar(eax);
    }
	
    return eax;
}

Nota: perdonen por no explicar con más detalle, pero seme aria más largo el tutorial de por sí ya está largo, bueno seguimos el tercer nivel nos pide un nombre y un serial, donde el cual usaremos el mismo nombre del primer nivel mi generador de claves lo usa para no enredarnos mucho



Para este nivel volvemos a irnos a las string y buscamos el mensaje incorrecto que es este


Y nos dirige a esta zona


Como podemos ver esta la API que compara y los mensajes correcto e incorrecto y por lógica el CALL que está arriba es el de la generación del serial, el que tiene el breakpoint así que entraremos a él con F7 para analizarlo y nos muestra esto

00007FF7B38A1F2B | 55                       | push rbp                                               |
00007FF7B38A1F2C | 48:89E5                  | mov rbp,rsp                                            |
00007FF7B38A1F2F | 48:83EC 40               | sub rsp,40                                             |
00007FF7B38A1F33 | 48:894D 10               | mov qword ptr ss:[rbp+10],rcx                          | [rbp+10]:__pioinfo
00007FF7B38A1F37 | 48:8955 18               | mov qword ptr ss:[rbp+18],rdx                          | [rbp+18]:"6565\n\n\n8\n\n1D2D-58DC\n\n"
00007FF7B38A1F3B | 4C:8945 20               | mov qword ptr ss:[rbp+20],r8                           |
00007FF7B38A1F3F | 48:8B45 10               | mov rax,qword ptr ss:[rbp+10]                          | [rbp+10]:__pioinfo
00007FF7B38A1F43 | 48:89C1                  | mov rcx,rax                                            |
00007FF7B38A1F46 | E8 54FFFFFF              | call geckoacademy2026_7_challenge.7FF7B38A1E9F         |
00007FF7B38A1F4B | 8945 FC                  | mov dword ptr ss:[rbp-4],eax                           |
00007FF7B38A1F4E | C745 F8 00000000         | mov dword ptr ss:[rbp-8],0                             |
00007FF7B38A1F55 | EB 24                    | jmp geckoacademy2026_7_challenge.7FF7B38A1F7B          |
00007FF7B38A1F57 | 8B45 F8                  | mov eax,dword ptr ss:[rbp-8]                           |
00007FF7B38A1F5A | 48:63D0                  | movsxd rdx,eax                                         |
00007FF7B38A1F5D | 48:8B45 18               | mov rax,qword ptr ss:[rbp+18]                          | [rbp+18]:"6565\n\n\n8\n\n1D2D-58DC\n\n"
00007FF7B38A1F61 | 48:01D0                  | add rax,rdx                                            |
00007FF7B38A1F64 | 0FB600                   | movzx eax,byte ptr ds:[rax]                            |
00007FF7B38A1F67 | 0FB6D0                   | movzx edx,al                                           |
00007FF7B38A1F6A | 8B45 FC                  | mov eax,dword ptr ss:[rbp-4]                           |
00007FF7B38A1F6D | 89C1                     | mov ecx,eax                                            |
00007FF7B38A1F6F | E8 75FFFFFF              | call geckoacademy2026_7_challenge.7FF7B38A1EE9         |
00007FF7B38A1F74 | 8945 FC                  | mov dword ptr ss:[rbp-4],eax                           |
00007FF7B38A1F77 | 8345 F8 01               | add dword ptr ss:[rbp-8],1                             |
00007FF7B38A1F7B | 837D F8 07               | cmp dword ptr ss:[rbp-8],7                             |
00007FF7B38A1F7F | 7E D6                    | jle geckoacademy2026_7_challenge.7FF7B38A1F57          |
00007FF7B38A1F81 | 8B45 FC                  | mov eax,dword ptr ss:[rbp-4]                           |
00007FF7B38A1F84 | 35 D1DEC0DE              | xor eax,DEC0DED1                                       |
00007FF7B38A1F89 | 8945 F4                  | mov dword ptr ss:[rbp-C],eax                           |
00007FF7B38A1F8C | 8B45 F4                  | mov eax,dword ptr ss:[rbp-C]                           |
00007FF7B38A1F8F | BA 0B000000              | mov edx,B                                              | 0B:'\v'
00007FF7B38A1F94 | 89C1                     | mov ecx,eax                                            |
00007FF7B38A1F96 | E8 E5F4FFFF              | call geckoacademy2026_7_challenge.7FF7B38A1480         |
00007FF7B38A1F9B | 8945 F4                  | mov dword ptr ss:[rbp-C],eax                           |
00007FF7B38A1F9E | 8B4D FC                  | mov ecx,dword ptr ss:[rbp-4]                           |
00007FF7B38A1FA1 | 48:8B45 20               | mov rax,qword ptr ss:[rbp+20]                          |
00007FF7B38A1FA5 | 8B55 F4                  | mov edx,dword ptr ss:[rbp-C]                           |
00007FF7B38A1FA8 | 895424 20                | mov dword ptr ss:[rsp+20],edx                          |
00007FF7B38A1FAC | 41:89C9                  | mov r9d,ecx                                            |
00007FF7B38A1FAF | 4C:8D05 22F20000         | lea r8,qword ptr ds:[7FF7B38B11D8]                     | 00007FF7B38B11D8:"%08X%08X"
00007FF7B38A1FB6 | BA 11000000              | mov edx,11                                             |
00007FF7B38A1FBB | 48:89C1                  | mov rcx,rax                                            |
00007FF7B38A1FBE | E8 1DDC0000              | call geckoacademy2026_7_challenge.7FF7B38AFBE0         |
00007FF7B38A1FC3 | 90                       | nop                                                    |
00007FF7B38A1FC4 | 48:83C4 40               | add rsp,40                                             |
00007FF7B38A1FC8 | 5D                       | pop rbp                                                |
00007FF7B38A1FC9 | C3                       | ret                                                    |


Bueno solo se miran unos CALL y al último un xoreo de DEC0DED1, pero bueno aquí les muestro lo que tienen esos CALL el primero

00007FF7B38A1E9F | 55                       | push rbp                                               |
00007FF7B38A1EA0 | 48:89E5                  | mov rbp,rsp                                            |
00007FF7B38A1EA3 | 48:83EC 10               | sub rsp,10                                             |
00007FF7B38A1EA7 | 48:894D 10               | mov qword ptr ss:[rbp+10],rcx                          | [rbp+10]:__pioinfo
00007FF7B38A1EAB | C745 FC 05150000         | mov dword ptr ss:[rbp-4],1505                          |
00007FF7B38A1EB2 | EB 21                    | jmp geckoacademy2026_7_challenge.7FF7B38A1ED5          |
00007FF7B38A1EB4 | 8B45 FC                  | mov eax,dword ptr ss:[rbp-4]                           |
00007FF7B38A1EB7 | C1E0 05                  | shl eax,5                                              |
00007FF7B38A1EBA | 89C2                     | mov edx,eax                                            |
00007FF7B38A1EBC | 8B45 FC                  | mov eax,dword ptr ss:[rbp-4]                           |
00007FF7B38A1EBF | 01C2                     | add edx,eax                                            |
00007FF7B38A1EC1 | 48:8B45 10               | mov rax,qword ptr ss:[rbp+10]                          | [rbp+10]:__pioinfo
00007FF7B38A1EC5 | 0FB600                   | movzx eax,byte ptr ds:[rax]                            |
00007FF7B38A1EC8 | 0FB6C0                   | movzx eax,al                                           |
00007FF7B38A1ECB | 31D0                     | xor eax,edx                                            |
00007FF7B38A1ECD | 8945 FC                  | mov dword ptr ss:[rbp-4],eax                           |
00007FF7B38A1ED0 | 48:8345 10 01            | add qword ptr ss:[rbp+10],1                            | [rbp+10]:__pioinfo
00007FF7B38A1ED5 | 48:8B45 10               | mov rax,qword ptr ss:[rbp+10]                          | [rbp+10]:__pioinfo
00007FF7B38A1ED9 | 0FB600                   | movzx eax,byte ptr ds:[rax]                            |
00007FF7B38A1EDC | 84C0                     | test al,al                                             |
00007FF7B38A1EDE | 75 D4                    | jne geckoacademy2026_7_challenge.7FF7B38A1EB4          |
00007FF7B38A1EE0 | 8B45 FC                  | mov eax,dword ptr ss:[rbp-4]                           |
00007FF7B38A1EE3 | 48:83C4 10               | add rsp,10                                             |
00007FF7B38A1EE7 | 5D                       | pop rbp                                                |
00007FF7B38A1EE8 | C3                       | ret                                                    |


El segundo y el CALL que está dentro de él

00007FF7B38A1EE9 | 55                       | push rbp                                               |
00007FF7B38A1EEA | 48:89E5                  | mov rbp,rsp                                            |
00007FF7B38A1EED | 48:83EC 20               | sub rsp,20                                             |
00007FF7B38A1EF1 | 894D 10                  | mov dword ptr ss:[rbp+10],ecx                          |
00007FF7B38A1EF4 | 89D0                     | mov eax,edx                                            |
00007FF7B38A1EF6 | 8845 18                  | mov byte ptr ss:[rbp+18],al                            |
00007FF7B38A1EF9 | 0FB645 18                | movzx eax,byte ptr ss:[rbp+18]                         |
00007FF7B38A1EFD | 3145 10                  | xor dword ptr ss:[rbp+10],eax                          |
00007FF7B38A1F00 | 8B45 10                  | mov eax,dword ptr ss:[rbp+10]                          |
00007FF7B38A1F03 | BA 07000000              | mov edx,7                                              |
00007FF7B38A1F08 | 89C1                     | mov ecx,eax                                            |
00007FF7B38A1F0A | E8 71F5FFFF              | call geckoacademy2026_7_challenge.7FF7B38A1480         |
00007FF7B38A1F0F | 8945 10                  | mov dword ptr ss:[rbp+10],eax                          |
00007FF7B38A1F12 | 816D 10 4786C861         | sub dword ptr ss:[rbp+10],61C88647                     |
00007FF7B38A1F19 | 8B45 10                  | mov eax,dword ptr ss:[rbp+10]                          |
00007FF7B38A1F1C | C1E8 0D                  | shr eax,D                                              |
00007FF7B38A1F1F | 3145 10                  | xor dword ptr ss:[rbp+10],eax                          |
00007FF7B38A1F22 | 8B45 10                  | mov eax,dword ptr ss:[rbp+10]                          |
00007FF7B38A1F25 | 48:83C4 20               | add rsp,20                                             |
00007FF7B38A1F29 | 5D                       | pop rbp                                                |
00007FF7B38A1F2A | C3                       | ret                                                    |

00007FF7B38A1480 | 55                       | push rbp                                               |
00007FF7B38A1481 | 48:89E5                  | mov rbp,rsp                                            |
00007FF7B38A1484 | 894D 10                  | mov dword ptr ss:[rbp+10],ecx                          |
00007FF7B38A1487 | 8955 18                  | mov dword ptr ss:[rbp+18],edx                          |
00007FF7B38A148A | 8365 18 1F               | and dword ptr ss:[rbp+18],1F                           |
00007FF7B38A148E | 8B45 18                  | mov eax,dword ptr ss:[rbp+18]                          |
00007FF7B38A1491 | 8B55 10                  | mov edx,dword ptr ss:[rbp+10]                          |
00007FF7B38A1494 | 89C1                     | mov ecx,eax                                            |
00007FF7B38A1496 | D3C2                     | rol edx,cl                                             |
00007FF7B38A1498 | 89D0                     | mov eax,edx                                            |
00007FF7B38A149A | 5D                       | pop rbp                                                |
00007FF7B38A149B | C3                       | ret                                                    |

Y el tercer CALL es el mismo que esta adentro del segundo y lo que hace es un desplazamiento de bits hacia la izquierda con la instrucción rol, bueno creo que aquí les dejo su versión en JavaScript
    eax=5381;
    for(x=0;x<nombre.length;x++)
    {
       edx=eax<<5;
       edx=edx+eax;
       digi=nombre[x].charCodeAt(0);
	   eax=digi ^ edx; 
    }
    let aa=new Array(19,55,192,255,238,66,153,1);
    for(x=0;x<aa.length;x++)
    {
       eax=eax ^ aa[x];
      if(eax<0)
      {
         eax=4294967296 + eax;
      }
       eax =rol32(eax,7);
       eax=eax - 1640531527;
       ebx = eax >>> 13;
       eax=eax ^ ebx;
      if(eax<0)
      {
         eax=4294967296 + eax;
      }
    }
    ebx=eax;
    eax=eax ^ 3737181905;
   
    if(eax<0)
    {
       eax=4294967296 + eax;
    }
   
    eax=rol32(eax,11);
    digi=eax.toString(16);
    while(digi.length<8)
    {
       digi="0" + digi;
    }
    document.getElementById("pass3").value=ebx.toString(16).toUpperCase() + digi.toUpperCase();
  }
  else
  {
     alert("El Nombre Debe Ser Igual o Mayor a 5 Digitos...");
  }

Ahora para el último nivel solo les diré como encontrar la función encargada de validar el nivel, así que solo nos vamos a los string de nuevo y buscamos el mensaje correcto y también el incorrecto y es este


Después de eso solo damos doble clic en él y nos dirige a esta zona


El CALL que tiene el breakpoint es el que genera o válida la clave para pasar el nivel 4, perdón por no entrar en detalles, pero se me hace muy largo explicar todo el proceso así que solo les deje la versión en JavaScript del fuerza bruta 

Bueno saludos Flamer y sé que me falto explicar mucho pero estresa tanto escribir y como decía PerterPunk es más fácil resolverlos que escribir un tutorial, a este le falto mucho, pero no quise entrar en detalles... Espero y me entiendan saludos


jueves, 8 de octubre de 2026

Solucion del Crackme De DiS[IP]

Hola amigos soy flamer de nuevo ahora veremos la solución del crackme de DiS[IP], es algo sencillo, pero divertido este reto lo mire en un tutorial de neutrino pero el explicaba otra cosa yo explicaré la solución y su generador de claves

bueno aqui una foto del reto


Así que primero buscamos las string y encontramos esto


Así que damos doble clic en el mensaje correcto y nos lleva a esta zona


Así que ingresamos un nombre yo ingresare "polo" y como serial "123456" y vemos que toma el primer digito del campo nombre que es "p" que su valor en hexadecimal es 70 después pregunta si el dígito tomado vale 5A, 7A y 39 en hexadecimal y si es así sele resta 1.

Después en la línea 00401127 suma el registro eax más 61 en hexadecimal y en la línea 0040112A junta 61 y 70 en el registro EBX quedando así 00006170 y en la línea 0040112D  le suma 1 al primer dígito que es "P" quedando el registro EBX 00006171 para después tomas 2 dígitos del campo del serial y los almacena en el registro ecx que es 3231 y en la línea 0040113A pregunta si bx y cx son iguales y si no te manda al cartelito incorrecto aquí les dejo una foto



Y se repite el ciclo después toma el segundo dígito del campo nombré y eax va aumentando de valor así que en la línea 00401127 eax valdrá 1 + 61 dará 62 y luego tomara los siguientes 2 dígitos del serial y los comparara y así sucesivamente bueno les dejo el código del ensamblado

004010FE | 33C0                     | xor eax,eax                                    |
00401100 | 33DB                     | xor ebx,ebx                                    |
00401102 | 33C9                     | xor ecx,ecx                                    |
00401104 | A3 39304000              | mov dword ptr ds:[403039],eax                  |
00401109 | 33DB                     | xor ebx,ebx                                    |
0040110B | 8A98 14304000            | mov bl,byte ptr ds:[eax+403014]                | eax+403014:"lo"
00401111 | 80FB 5A                  | cmp bl,5A                                      | 5A:'Z'
00401114 | 75 02                    | jne creakme.401118                             |
00401116 | FECB                     | dec bl                                         |
00401118 | 80FB 7A                  | cmp bl,7A                                      | 7A:'z'
0040111B | 75 02                    | jne creakme.40111F                             |
0040111D | FECB                     | dec bl                                         |
0040111F | 80FB 39                  | cmp bl,39                                      | 39:'9'
00401122 | 75 02                    | jne creakme.401126                             |
00401124 | FECB                     | dec bl                                         |
00401126 | 50                       | push eax                                       |
00401127 | 83C0 61                  | add eax,61                                     |
0040112A | 02F8                     | add bh,al                                      |
0040112C | 58                       | pop eax                                        |
0040112D | 80C3 01                  | add bl,1                                       |
00401130 | 66:8B0C45 1A304000       | mov cx,word ptr ds:[eax*2+40301A]              | eax*2+40301A:"mcpd"
00401138 | 40                       | inc eax                                        |
00401139 | 50                       | push eax                                       |
0040113A | 66:3BD9                  | cmp bx,cx                                      |
0040113D | 75 37                    | jne creakme.401176                             |
0040113F | 8305 39304000 01         | add dword ptr ds:[403039],1                    |
00401146 | 58                       | pop eax                                        |
00401147 | 3B05 25304000            | cmp eax,dword ptr ds:[403025]                  |
0040114D | 75 BA                    | jne creakme.401109                             |
0040114F | 50                       | push eax                                       |

Ahora el código del generador de claves

<html>
<head>
<title>Generador De Claves Del Crackme DiS[IP] ...:::Flamer:::...</title>
</head>
<body bgcolor="black">
<center>
<marquee style="font-size:30;color:yellow;">Generador De Claves Del Crackme DiS[IP] ...:::Flamer:::...</marquee><br><br>
<label style="color:white;">Nombre:</label>
<input type="text" id="nom" size='30' style="background-color:Gray;color:white;text-align:center;">
<input type="button" value="Copy" onclick="copiar1()"><br><br>
<label style="color:white;">Serial Nivel:</label>
<input type="text" id="pass" size='50' style="background-color:Gray;color:white;text-align:center;">
<input type="button" value="Copy" onclick="copiar2()"><br><br>
<input type="button"  value="Generar" onclick="genera()" id="boton1">
</center>
<script>
function copiar1() 
{
   let c=document.getElementById('nom'); 
   navigator.clipboard.writeText(c.value);
}
//==================================================================================
function copiar2() 
{
   let c=document.getElementById('pass'); 
   navigator.clipboard.writeText(c.value);
}
//==================================================================================
function genera()
{
   let nick=document.getElementById("nom").value;
   let x,digi,s=97,clave="";
   
   for(x=0;x<nick.length;x++)
   {
      digi=nick[x].charCodeAt(0);
      if(digi==122 || digi==90 || digi==57)
      {
         digi--;
      }
      digi++;
      clave=clave + String.fromCharCode(digi) + String.fromCharCode(s);
      s++;
   }
   document.getElementById("pass").value=clave;
}
</script>
</body>
</html>

Aquí una foto


Solo copean el código en el bloc de notas y aguardan como "genera.html" y lo ejecutan y ponemos como nombre "polo" y nos da el siguiente serial "qapbmcpd" y lo ponemos en el crackme y nos arroja esto


Bueno creo que eso es todo por ahora espero les haya gustado saludo Flamer y hasta la próxima y saludos a neutrino por el tutorial que me mando y todos los crackslatinos

sábado, 3 de octubre de 2026

Solucion al Crackme 3 De Enigmagroup

Hola amigos hoy veremos el crackme 3 de Enigmagroup el cual es algo sencillo, pero poco a poco los haremos hasta llegar al último el 14, bueno aquí una foto del reto


Así que lo abrimos con el x32dbg y buscamos entre las APIs que usa para ver cual nos lleva a la solucion... yo encontre una API que compara los valores que ingresamos, asi que buscamos la API  vbaVarTstEq y ponemos un breakpoint

Nota: si se preguntan como llegue a esa API es porque anteriormente lo analice y solo explico la forma más rápida de explicar la solución


Y damos ejecutar e ingresamos como serial 123456 y presionamos el botón submit y se detiene justo hay en esa API


Así que entramos en ese CALL presionando F7 y seguimos con F7 hasta llegar a la zona que compara el valor que ingresamos y ver con cuál string compara, pero al parecer ya se mira en la imagen de arriba cuál string es, pero seguimos con F7 hasta llegar a esta zona y estar seguros con que compara


Y como vemos la string que es comparada con 123456 es DEBUG54321 así que presionamos F9 e ingresamos ese serial y se detiene, pero damos ejecutar con F9 y nos arroja esto


Bueno amigo espero les halla gustado saludos Flamer y hasta la proxima