[Reto] Crackme Loki-Mouse Flamer

[Flamer]

Hola amigos les presento mi nuevo crackme es nivel 1 el objetivo es crear el keygen o sacar una pass valida no vale parchar


Reto : Crackme

Nombre : Loki-Mouse

Autor : Flamer

Lenguaje : Dev-c++

Nivel : 1

Objectivo : Serial valido o keygen funcional

Descarga: http://www.mediafire.com/file/b8jf1pkbk77c1hm/Crackme_Loki-Mouse.rar/file

[tincopasan]

hola Flamer:
                  si bien es nivel 1(yo debo ser nivel 2 jajaja) y como estoy "desocupado", lo estuve mirando para entretenerme un rato.
Serial ==  1027986032
ahora soy muy "vago" para ponerme a escribir un tuto o un keygen, lo dejo para otro o para muuuucho más adelante.
Sabés que siempre te hago comentarios y espero que no los tomes mal, creo que estás usando mal el término hacker, en este caso sería mejor cracker.Aunque a nadie la importa la diferencia.
Gracias por el entretenimiento. Saludos

[Flamer]

hola Flamer:
                  si bien es nivel 1(yo debo ser nivel 2 jajaja) y como estoy "desocupado", lo estuve mirando para entretenerme un rato.
Serial ==  1027986032
ahora soy muy "vago" para ponerme a escribir un tuto o un keygen, lo dejo para otro o para muuuucho más adelante.
Sabés que siempre te hago comentarios y espero que no los tomes mal, creo que estás usando mal el término hacker, en este caso sería mejor cracker.Aunque a nadie la importa la diferencia.
Gracias por el entretenimiento. Saludos

no nunca los tomo a mal me agradan.....siempre me he confundido y no no mas creo ya que según tengo entendido el cracker es lo opuesto del hacker.....ya que el cracker usa las herramientas para robar y delinquir mientras que el hacker lo hace por aprender

aquí entra la confusión ya que mucha gente les llama cracker a las personas que realizan la ingeniera inversa sin saber que lo hacemos por puro entretenimiento

bueno pero creo que me estoy saliendo del tema....el serial es correcto

saludos Flamer

[@XSStringManolo]

Comúnmente se le llama Cracker al ciberdelincuente y hacker al geek de la ciberseguridad.

Para mi un cracker es alguien especializado en ingeniería inversa con el objetivo de piratear software o vulnerarlo para romper su seguridad independientemente de su objetivo.
Y hacker para mi es cualquiera con conocimientos básicos en ciberseguridad o herramientas de hacking que tenga la capacidad de vulnerar, obtener información o infiltrarse en un sistema usando como herramienta la ciberseguridad.
Después podrías clasificarlos según su metodología, conocimientos, intereses, ideología, objetivos, etc.
Hay hackers que se dedican a las estafas, robos, suplantaciones, infecciones masivas, venta y redistribución de contenido legal...
Otros se dedican a proteger los sistemas, revisarlos en busca de fallos de seguridad, arreglarlos, defenderlos...
Otros son mercenarios y tanto trabajan de un lado como del otro según le salga más rentable.

[karmany]

Bueno, para que la gente se anime a estudiar el Crackme me he propuesto analizarlo y crear un sencillo Keygen.
Para el keygen, aunque valen muchos caracteres, solo voy a usar números para evitar poner muchas condiciones en el código fuente. Pongo un enlace al final con el código fuente del keygen, el exe del mismo y una copia del crackme por si desapareciera en un futuro.

Carga el crackme en un depurador, yo lo hice con varios, pero para explicarlo lo hago con OllyDBGv2 en W10. Lo primero que llama la atención es que pesa muchísimo para el poco código que lleva, a ver si Flamer nos comenta el porqué.

Encontrar el código es sencillo buscando en las strings: botón dcho > search for > all referenced strings. Así se llega rápido al código.

Explicación del código

Código (asm) [Seleccionar] Expandir

00401700  cmp eax,0A
Nos indica que el serial tiene que tener exactamente 10 caracteres:
XXXXXXXXXX

El primer valor, voy a poner uno cualquiera: "1" = 31h
1XXXXXXXXX

Aquí trabaja con valor1 y valor6:

Código (asm) [Seleccionar] Expandir

CPU Disasm
Address   Hex dump          Command                                  Comments
00401750  |.  83E8 60       sub eax,60
00401753  |.  8945 DC       mov dword ptr ss:[ebp-24],eax
00401756  |.  837D DC 08    cmp dword ptr ss:[ebp-24],8
0040175A  |.  0F8E 62020000 jle 004019C2

En esa parte hace estas operaciones (todo en HEX):
valor6 + valor1 - 60 > 8; valor6 + 31h - 60h > 8h;
valor6 > 37h; Por lo tanto, valor6 = 38h ("8") o 39h.
1XXXX8XXXX

El valor 2 es un número aleatorio entre 0 y 9. Pongo por ej 7:
17XXX8XXXX

Un poco más adelante, empieza a realizar un montón de operaciones con los valores 1, 2, 6 desde 4017E3 hasta 401818. En este ejemplo, poniendo en el depurador el serial anterior, y BP en 401818, el resultado en eax de esas operaciones es: 6

Ahora volvemos a analizar un poco más arriba y verás que resta 30h al valor5 en 4017D7 y la comparación en 401821 compara el 6 del párrafo anterior con esto último:
valor5 = 6 + 30;
valor5 = 36h = "6"
17XX68XXXX

valor3 tiene que ser menor que 33h, mira en:

Código (asm) [Seleccionar] Expandir

CPU Disasm
Address   Hex dump          Command                                  Comments
00401861  |.  837D CC 32    cmp dword ptr ss:[ebp-34],32
00401865  |.  7F 73         jg short 004018DA
valor3 puede ser 32h("2"), 31h("1") o 30h("0")
172X68XXXX

valor4 tiene que ser mayor que 35h, mira en:

Código (asp) [Seleccionar] Expandir

CPU Disasm
Address   Hex dump          Command                                  Comments
00401867  |.  837D C8 35    cmp dword ptr ss:[ebp-38],35
0040186B  |.  7E 6D         jle short 004018DA
valor4 puede ser 36h, 37h, 38h o 39h.
172668XXXX

Y los 4 últimos caracteres pueden ser cualquier valor:
172668FORO

Dejo el código fuente que he realizado para el keygen, en Visual C++ 2019:

Código (cpp) [Seleccionar] Expandir

// Keygen Loki-Mouse.cpp
//

#include <iostream>
#include<time.h>
#include <sstream>

using namespace std;

int codigo_asm(int num1, int num2)
{
int resultado;
_asm
{
mov eax, num1
mov edx, num2
imul edx
sar edx, 2
mov eax, num1
sar eax, 0x1F
sub edx, eax
mov num2, edx
shl edx, 2
add edx, num2
add edx, edx
mov eax, num1
sub eax, edx
add eax, 0x30

mov resultado, eax
}
       return resultado;
}

int main()
{
int numHex = 0x00;
int hexCaracter[11] = {};
string caracter[11] = {};

srand(time(NULL)); //Inicializa números aleatorios

cout << "Keygen Crackme Loki-Mouse\n==========================\n\n";

cin.clear();
cout << "Para generar autom\240ticamente un serial v\240lido, pulsa una tecla...";
cin.ignore();

// El serial tiene que tener exactamente 10 caracteres

// ----------------
// Caracteres 1 y 6
// ----------------

// El carácter 1 va a ser un número aleatorio entre el 0(30hex) y 9(39hex):
hexCaracter[1] = 0x30 + rand() % (10);

// El carácter 6 responde a esta fórmula: c6 + c1 - 60 > 8; c6 > 68 - c1;
hexCaracter[6] = 0x69 - hexCaracter[1]; // Este es el primer valor válido
hexCaracter[0] = 0x39 - hexCaracter[6]; //Número de valores también válidos hasta el 9 (39h)
if (hexCaracter[0] != 0)
{
hexCaracter[6] = hexCaracter[6] + rand() % hexCaracter[0]; //Calcula aleatoriamente un valor válido entre todos los posibles.
}

// ----------
// Caracter 2
// ----------
// Un número aleatorio entre 0 y 9
hexCaracter[2] = 0x30 + rand() % (10);

// -----------------------------------------
// Realiza operaciones en ASM con C1, C2, C6
// -----------------------------------------
hexCaracter[0] = hexCaracter[2] + hexCaracter[1] + hexCaracter[6] - 0x90;


// ----------
// Caracter 5
// ----------
hexCaracter[5] = codigo_asm(hexCaracter[0], 0x66666667);

// ----------
// Caracter 3
// ----------
// Tiene que ser < 33h
hexCaracter[3] = 0x30 + rand() % (2);

// ----------
// Caracter 4
// ----------
// Tiene que ser > 35h
hexCaracter[4] = 0x36 + rand() % (3);

// --------------------
// Caracter 7, 8, 9, 10
// --------------------
// Cualquiera, yo voy a usar solo números, pero vale cualquier otro carácter
for (int i = 7; i < 11; i++)
{
hexCaracter[i] = 0x30 + rand() % (10);
}

        // Convertir números en cadena de texto y mostrarlos en pantalla
for (int i = 1; i < 11; i++)
{
caracter[i] = hexCaracter[i];
        cout << caracter[i];
}

cout << "\n";
system("pause");
return 0;
}


Y aquí la descarga:
Descargar Keygen desde Mega

Muchas gracias Flamer por el reto

[farma]

Qué manera tan sencilla de explicarlo, especialmente para los que nos gusta leer sobre el tema pero no le podemos dedicar mucho tiempo.

Gracias por el crackme y el tuto!

[Acronys]

Que mejor explicación que la de karmany

Dejo mi key porsia:

y=2\4Vvs+B

Dejo mi código fuente ya que en mi caso lo hice con la tabla de caracteres ASCII.

Y bueno, llego un poco tarde pero lo hice. También atareado con otras cosas pero que he querido dedicarle a esto mas tiempo.

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <random>


using namespace std;

int randomnumber()
{
   int Min = 33;
   int Max = 126;

   int Number = std::rand() % (Max + 1 - Min) + Min;


   return Number;

}

int main()
{

std::srand(std::time(nullptr)); //seed

   string key = "1234567899";

   bool finish = true;

   while(finish)
   {
       unsigned char a = randomnumber();
       unsigned char b = randomnumber();
       unsigned char c = randomnumber();
       unsigned char d = randomnumber();
       unsigned char e = randomnumber();
       unsigned char f = randomnumber();
       unsigned char g = randomnumber();
       unsigned char h = randomnumber();
       unsigned char i = randomnumber();
       unsigned char j = randomnumber();

       key[0] = a;
       key[1] = b;
       key[2] = c;
       key[3] = d;
       key[4] = e;
       key[5] = f;
       key[6] = g;
       key[7] = h;
       key[8] = i;
       key[9] = j;


       signed int caux;

       if(a+f>104)
       {
           finish = false;
       }

       caux = (signed char) e;
       caux = caux - 0x30;

       a += b;

       f += a;

       f = f - 0x90;

       int eax, edx;
       edx = 0x66666667;
       eax = f;
       long long result = (long long) eax * (long long) edx;
       eax = result & 0xffffffff;
       edx = result >> 32;

       edx = edx >> 2;

       eax = f;

       eax = eax >> 0x1F;
       edx -= eax;

       eax = edx;

       eax = eax << 2;
       eax += edx;
       eax += eax;

       f -= eax;

       if(f != caux)
       {
           finish = true;
       }

       if(c > 0x32)
       {
           finish = true;
       }
       if(d <= 0x35)
       {
           finish = true;
       }


   }

   cout << key << endl;

   return 0;


}



Edit: Ah, una cosa que me pareció interesante que no me acordaba era que podía utilizar las instrucciones en asm mas directo que lo que hice yo. Gracias Karmany jeje

Gracias por el reto Flamer.

[Flamer]

veo que no seles complico.....pienso hacer otro

Lo primero que llama la atención es que pesa muchísimo para el poco código que lleva, a ver si Flamer nos comenta el porqué.

[/quote]

no se por que pesara tanto como dices......sera el compilador..... lo compile con Dev-c++

[BloodSharp]

Lindo crackme para pasar el tiempo

Key: 6x0d13ezuu

keygen.py

Código (python) [Seleccionar] Expandir

#!/usr/bin/env python2

import random

serial = [1,2,3,4,5,6,7,8,9,0]
serial_string = ""

for x in range(0,10):
serial[x] = random.randint(ord('a'),ord('z'))

serial[0] = random.randint(ord('0'),ord('z'))
serial[5] = 9 + 96 - serial[0]
serial[1] = random.randint(ord('a'),ord('z'))
serial[4] = ((serial[1] + serial[0] + serial[5] - 144) % 10) + 48
serial[2] = random.randint(ord('0'),ord('2'))
serial[3] = random.randint(ord('6'),ord('z'))

for x in serial:
serial_string += str(chr(x))
print serial_string


B#