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

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

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

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:

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:

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:

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:

// 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

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.

#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.

Lindo crackme para pasar el tiempo

Key: 6x0d13ezuu

keygen.py

#!/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#