Solucion Al KeyFileMe#01 by deurus

Hola amigos hoy veremos un reto del usuario deurus es un keyfile(lo baje de crackmes.one y de hay saque el nombre de usuario) es un reto igual que un crackme solo con la diferencia que el serial se guarda en un archivo no se escribe en un cuadro de texto como los demás retos, aquí una foto del reto

Damos clic en el botón aceptar y se cierra, así que lo abrimos con x32dbg y buscaremos como se llama el archivo que leerá la contraseña, asi que buscamos en los string el mensaje que nos muestra arriba y aquí esta

Así que damos doble clic en él y nos manda a esta zona... Nota: en la imagen de arriba nos muestra el mensaje correcto y el incorrecto, pero eso lo veremos después

Así que ponemos un breakpoint como lo muestra la imagen, pero al parecer en la imagen se puede ver un string que dice "key.txt" al parecer así se llamara el archivo, asi que lo ejecutamos y vemos que nos muestra

Y si hay esta la ruta, entonces el archivo se llama "key.txt" así que pasamos a crearlo para ver que sucede y adentro le ponemos "123456" y vemos que ahora al ejecutarlo no se cierra, entonces ahora nos iremos de nuevo a los string y buscamos el mensaje de registrado

Y nos lleva a esta zona 

Como vemos en esas líneas compara así que más arriba se genera el serial así que nos vamos hasta la línea 004654A2 y miramos que compara 6 con 14 que en decimal es 20

Como vemos esta comparando lo que está dentro del archivo que son 6 dígitos con 20, eso quiere decir que el serial a buscar es de 20 dígitos, así que le pondremos 20 dígitos al archivo "key.txt" yo le pondré como serial "1234567890abcdefghij" y pasamos el primer filtro, pero ahora nos topamos con otro este

Y si entramos en el CALL de arriba contiene este código

004653B3 | 8BF0                     | mov esi,eax                                    | esi:"1234567890abcdefghij"
004653B5 | 33C0                     | xor eax,eax                                    |
004653B7 | EB 09                    | jmp keyfileme#01.4653C2                        |
004653B9 | 80C2 D0                  | add dl,D0                                      |
004653BC | 80EA 0A                  | sub dl,A                                       |
004653BF | 73 09                    | jae keyfileme#01.4653CA                        |
004653C1 | 46                       | inc esi                                        | esi:"1234567890abcdefghij"
004653C2 | 8A16                     | mov dl,byte ptr ds:[esi]                       | esi:"1234567890abcdefghij"
004653C4 | 84D2                     | test dl,dl                                     |
004653C6 | 75 F1                    | jne keyfileme#01.4653B9                        |
004653C8 | B0 01                    | mov al,1                                       |
004653CA | 5E                       | pop esi                                        | esi:"1234567890abcdefghij"
004653CB | 5B                       | pop ebx                                        | ebx:"1234567890abcdefghij"
004653CC | C3                       | ret                                            |

Así que lo traceamos y averiguamos que solo acepta números, si ponemos letras nos rebota el salto, así que modificamos el serial del archivo yo pondré "01234567890123456789"

Ahora pondré como serial en el archivo  "11111222223333344444" y nos muestra lo siguiente

Ahora si seguimos ya sabremos que pasa con cada parte del serial y vemos que xorea 11111 con 34256

Y más abajo xorea 33333 con 65798 y nos da x resultado, así que vemos que solo toma 2 partes del código, la primera y la tercera aquí les dejo el código de generación del serial

0046551B | 8BF0                     | mov esi,eax                                    |
0046551D | 81F6 D0850000            | xor esi,85D0                                   |
00465523 | 8B45 E0                  | mov eax,dword ptr ss:[ebp-20]                  | [ebp-20]:"33333"
00465526 | E8 FD34FAFF              | call keyfileme#01.408A28                       |
0046552B | 8BF8                     | mov edi,eax                                    |
0046552D | 81F7 06010100            | xor edi,10106                                  |
00465533 | 8BC6                     | mov eax,esi                                    |
00465535 | 25 01000080              | and eax,80000001                               |
0046553A | 79 05                    | jns keyfileme#01.465541                        |
0046553C | 48                       | dec eax                                        |
0046553D | 83C8 FE                  | or eax,FFFFFFFE                                |
00465540 | 40                       | inc eax                                        |
00465541 | 0FB755 FE                | movzx edx,word ptr ss:[ebp-2]                  |
00465545 | 33C2                     | xor eax,edx                                    |
00465547 | 8945 DC                  | mov dword ptr ss:[ebp-24],eax                  |
0046554A | 8BC7                     | mov eax,edi                                    |
0046554C | C1E0 03                  | shl eax,3                                      |
0046554F | 0FB755 FC                | movzx edx,word ptr ss:[ebp-4]                  |
00465553 | 33C2                     | xor eax,edx                                    |
00465555 | 8945 D4                  | mov dword ptr ss:[ebp-2C],eax                  |
00465558 | 8BC6                     | mov eax,esi                                    |
0046555A | 99                       | cdq                                            |
0046555B | F77D D4                  | idiv dword ptr ss:[ebp-2C]                     |
0046555E | 3355 DC                  | xor edx,dword ptr ss:[ebp-24]                  |
00465561 | 03D7                     | add edx,edi                                    |
00465563 | 8995 F0FDFFFF            | mov dword ptr ss:[ebp-210],edx                 |

Bueno si analizan el código verán que en la línea 00465541...EDX toma el valor 1B desde una dirección de memoria

Y en la línea 0046554F....EDX vuelve a tomar otro valor desde otra dirección que es A

Si se preguntan que son esos valores pues les cuento el valor 1B es el día 27 en decimal y la A es el mes 10 en decimal que es octubre... Ahora veremos de donde toma esos valores para eso nos vamos a los módulos y pondremos un breakpoint en la API GetLocalTime esta

Y se detiene justo en la API y traceamos un poco con F8 y vemos en los registros los valores que les mencione

Bueno ya que saben de donde salen esos valores 1B y A y que toma los primeros 5 dígitos del serial y los otros 5 dígitos de la tercera parte del serial, hace las operaciones del código que les deje arriba y al final en la línea 00465611 compara si es menor que 65000

Y líneas más abajo en la línea 0046561D pregunta si es mayor a 9000

Y por último en la línea 0046562B pregunta si es menor a 10000

Bueno y si todo sale bien este es el mensaje que muestra

Ahora les dejo el generador de claves o keygen... Solo copean y pegan en el bloc de notas como "genera.html"

<html>
<head>
<title>Keygen Reto KeyFileMe#01 by deurus ...:::Flamer:::...</title>
</head>
<body bgcolor="black">
<center>
<marquee style="font-size:30;color:yellow;">Keygen Reto KeyFileMe#01 by deurus ...:::Flamer:::...</marquee><br><br>
<label style="color:white;">Serial:</label>
<input type="text" id="pass" size='80' style="background-color:Gray;color:white;text-align:center;">
<input type="button" value="Copy" onclick="copiar()"><br><br>
<input type="button"  value="Generar" onclick="genera()">
<input type="button" value="Descargar" onclick="descarga()">
</center>
<script>
function copiar() 
{
   let c=document.getElementById('pass'); 
   navigator.clipboard.writeText(c.value);
}
//==================================================================================
function genera()
{ 
   let fecha=new Date();
   let dia=fecha.getDate();
   let mes=fecha.getMonth() + 1;
   let p3,p1,s1,s2;
   
   [s1,s2]=busca1(mes);
   p1=s2;
   p3=s1;
   
   document.getElementById("pass").value=s2.toString() + aleatorio() + s1.toString() + aleatorio();  
}
//==================================================================================
function busca2(r1,r2,d)
{
   let p,x=9000;
   for(x=9000;x<50000;x++)
   {
      p=x;
      p=p ^ 34256;
      p=p % r1;
      p=(p ^ d) + r2;
     if(p>9000 && p<10000)
	 return x;
   }
   return -1;
}
//==================================================================================
function aleatorio()
{
   let r=parseInt(Math.random() * (99999 - 11111) + 11111);
   return r.toString();
}
//==================================================================================
function busca1(m)
{
   let x=65000,p,r1,r2,y;
   do
   {
      do 
      {
         x++;
	 p=x;
         p=p ^ 65798;
	 r2=p;
	 p=p << 3;
	 p=p ^ m;
	 r1=p;
      }while(p>65000)
     y=busca2(r1,r2,m);
   }while(y==-1);
   
   return [x,y];
}
function descarga()
{
   const a = document.createElement('a');
   a.href = 'data:text/plain;charset=utf-8,' + encodeURIComponent(document.getElementById("pass").value);
   a.download = 'key.txt';
   a.click();  
}
</script>
</body>
</html>

Aquí una imagen

Bueno amigos creo que eso es todo espero les haya gustado saludos Flamer

Instalar Node.js en Windows

Hola amigos hoy no vengo con un tutorial de un crackme, sino que veremos como instalar Node.js y si se preguntan para qué sirve pues bueno les digo con node.js ejecutaremos script de JavaScript fuera del navegador y no script que dependen de Wscript o Cscript para ejecutarse y aparte estos últimos están desactualizados y también creo que será más rápido sin usar el navegador.

Bueno para eso nos iremos a la página oficial que es esta

https://nodejs.org/es/download

Y hay elegimos descargar el instalador, el archivo .msi

Ya descargado damos doble clic y nos aparecerá esto

Damos clic en next y ahora en la nueva ventana aceptamos los términos y damos next

Ahora en la nueva ventana nos dice la ruta donde quedara instalado, así que damos next

En la siguiente ventana damos next

En la siguiente ventana lo dejamos como esta y solo damos next

Ahora en esta ventana nos pedirá permisos de administrador para instalarse, así que se los damos presionando install

Y empezara a instalarse y cuando finalice aparecerá esto

Así que damos clic en Finish y quedara instalado..... Ahora para averiguar si quedo instalado abriremos el CMD y tecleamos lo siguiente "node --version" y nos deberá de arrojar una versión como en la imagen

Ya con esto confirmamos que quedo instalado con éxito, ahora haremos nuestro primer programa en node.js así que abrimos un editor de texto yo usare Notepad++ y ponemos el siguiente código

console.log("Hola mundo hacking")

 Y lo aguardamos como "hola.js" en el escritorio y después desde el CMD lo ejecutamos así

node hola.js

Y en la ventana de CMD aparecerá esto

Bueno amigos espero les guste saludos Flamer 

Solucion al Crackme 4 De Enigmagroup

Hola amigos hoy les traigo la solución del crackme 4 de la página EnigmaGroup es algo sencillo igual que el anterior el crackme 3 pero sin tanto alarde empecemos, aquí la foto de la víctima

Ahora lo abriremos con el x32dbg y buscamos los string y miramos los siguientes

Bueno damos doble clic y nos lleva a esta zona

Como podemos ver más arriba del mensaje está un breackpoint en la API vbaVarTstEq que compara 2 cadenas así que lo ejecutamos y entramos a ese CALL con F7 y seguimos traceando con F7 hasta llegar a esta zona y ver con  que compara yo puse como serial "123456"

Y como podemos ver el serial que ingresamos es comparado con la palabra "ENIGMAROCKS", así que presionamos F9 e ingresamos ese serial y nos manda este cartelito 

Bueno amigos espero les guste saludos Flamer

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

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

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