Karpoff Spanish Tutor 1999-2002

Programa:

Crack-KeyGen-Me v1.0 de RAZiEL


 

PROTECCION: Name / Serial, Empacado
Objetivo: Hacer un Keygen
Descripcion: Excelente programita, realmente te hace pensar
Dificultad: Media.
DOWNLOAD: Sitio Oficial del Grupo [K-FoR]
Herramientas: OllyDBG, W32dasm, UPX v1.07, PEiDentifier v0.71 beta
CRACKER: ByTESCRK   FECHA: 07/01/2002

 

 INTRODUCCION

Creo que a muchos nos ha pasado (o por lo menos no me considero el único), después de crackear muchos programas y realmente ver lo fácil de ALGUNAS protecciones nos aburrimos y empezamos a crear nuestros Crackmes o a romper los ya existentes para desaburrirnos, bueno pues aqui va uno de los crackmes a los cuales les he destripado las entrañas y es que he andado mero destripador de crackmes en estos últimos días, creo que las aplicaciones ya no me suben tanto la bilirrubina como lo hacen los crackmes. Bueno pues alli les va este...

 

 AL ATAKE

Lo primero, ver el programa en sí, genial no podiamos esperar nada más es un Crackme y como tal solo tiene la cajita de texto del nombre y la del serial, ahora ingresamos nuestros datos falsos...

Nombre: ByTESCRK
Serial: 19770424

Ahora clic en el botón que dice Validar y el mensajito de error aparece...

El Número de Serie Introducido No Es Válido


De acuerdo vayamos a analizarlo (esto es esencial para cada archivo que vayamos a crackear, resulta que muchas veces únicamente nos vamos al W32DASM y cargamos el programa y vale, no nos dice nada y decimos Ooopps! I did again!)

Para esto usaremos el PEiDentifier v0.71 Beta, lo puedes encontrar en http://www.exetools.com, cargamos el programa y nos dice al hacer clic en el boton de Open File y seleccionar el archivo...

UPX 0.89.6 - 1.02 / 1.05 - 1.20 (Delphi) stub -> Markus & Lazlo

En otras palabras empacado con UPX, bueno nos conseguimos alguna version de UPX (no se si todas lo desempacan realmente no lo he probado, yo he usado la version 1.07 y me ha desempacado casi, lease bien digo CASI la mayoría de archivos empacados con UPX)

Para desempacar el programa realmente hacemos lo siguiente, en la carpeta que tenemos el programa UPX colocamos nuestro Crackme y ejecutamos desde DOS la siguiente línea...

UPX -d keyme.exe


Al cabo de algunos segundos nos dirá que el programa está desempacado y el pequeño programa de 95KB a pasado a ser de 213KB, ahora nos vamos a cargarlo al W32DASM (tambien pueden hacerlo con DeDe, ya que el programa está hecho en Delphi y creanme es mucho más fácil) buscamos en las Reference Strings por la cadena "El Número de Serie...", pues que bien, no está la cadena, pero hay algunas otras que me parecen interesantes por ejemplo esta... "Serial Correcto; Buen Cracker", si hacemos doble clic sobre ella llegaremos hasta aqui...

:0042D0A5 E846CDFEFF call 00419DF0   <= Vamos a poner un punto de ruptura aquí
:0042D0AA 8B45DC mov eax, dword ptr [ebp-24]
:0042D0AD 8B55E8 mov edx, dword ptr [ebp-18]   <= Wow! nos aparece el serial correcto en EBP-18
:0042D0B0 E81B68FDFF call 004038D0   <= Compara el Serial
:0042D0B5 7511 jne 0042D0C8   <= Si no es correcto da error
:0042D0B7 E8B8AFFDFF call 00408074

* Possible StringData Ref from Code Obj ->"Serial Correcto; Buen Cracker"
|
:0042D0BC B83CD24200 mov eax, 0042D23C
:0042D0C1 E806FAFFFF call 0042CACC
:0042D0C6 EB0A jmp 0042D0D2

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042D0B5(C)
|

* Possible StringData Ref from Code Obj ->"El N"   <= Aquí está la cadena que buscabamos
|
:0042D0C8 B864D24200 mov eax, 0042D264
:0042D0CD E8FAF9FFFF call 0042CACC

Pero como la idea no es encontrar el serial si no que crear un Keygen para este pequeño programa, entonces nos vamos a analizarlo con OllyDBG, vamos a cargar el programa y tambien a nuestra victima (ustedes ya saben File>Open, etc.etc.), pero primero un pequeño FAQ de Olly... realmente lo necesario...

1.- ¿Colocar un punto de Ruptura? R:/Presionar F2 sobre la línea
2.- ¿Tracear paso a paso? R:/Presionar F8 de línea en línea
3.- ¿Entrar a una llamada? R:/Con F7 o la tecla Enter
4.- ¿Ejecutar hasta el próximo punto de Ruptura? R:/Con F9
5.- ¿Buscar una direccion? R:/Presionar Ctrl+G

Vamos a poner un punto de ruptura en 0042CE34, presionamos Ctrl+G y escribimos la direccion, presionamos Enter y caemos en la direccion, ahora presionamos F2 y ahora F9 y se ha cargado el programa, ingresamos nuestros valores y clic en el botón Validar, caemos en el punto de ruptura y empezamos a analizar el código de generacion del serial, lo interesante realmente comienza aqui...

0042CE4D 680AD14200 PUSH KEYME.0042D10A  
0042CE52 64:FF30 PUSH DWORD PTR FS:[EAX]  
0042CE55 64:8920 MOV DWORD PTR FS:[EAX],ESP  
0042CE58 C745F801000000 MOV DWORD PTR SS:[EBP-8],1  
0042CE5F 8D45F0 LEA EAX,DWORD PTR SS:[EBP-10]  
Podemos ver la palabra clave para generar el serial...
0042CE62 BA20D14200 MOV EDX,KEYME.0042D120 ; ASCII 4D,"UYBIENHASDESCUBIERTOLACONSTANTEPEROTODAVIATEQUEDAPORHACERTOMANUMERITO78943789"
0042CE67 E87067FDFF CALL KEYME.004035DC  
0042CE6C 8D55EC LEA EDX,DWORD PTR SS:[EBP-14]  
0042CE6F 8B45F4 MOV EAX,DWORD PTR SS:[EBP-C]  
0042CE72 8B80E0010000 MOV EAX,DWORD PTR DS:[EAX+1E0]  
0042CE78 E873CFFEFF CALL KEYME.00419DF0  
0042CE7D 8D55DC LEA EDX,DWORD PTR SS:[EBP-24]  
0042CE80 8B45F4 MOV EAX,DWORD PTR SS:[EBP-C]  
0042CE83 8B80E0010000 MOV EAX,DWORD PTR DS:[EAX+1E0]  
0042CE89 E862CFFEFF CALL KEYME.00419DF0  
0042CE8E 837DDC00 CMP DWORD PTR SS:[EBP-24],0  
0042CE92 7417 JE SHORT KEYME.0042CEAB  
0042CE94 8D55D8 LEA EDX,DWORD PTR SS:[EBP-28]  
0042CE97 8B45F4 MOV EAX,DWORD PTR SS:[EBP-C]  
0042CE9A 8B80F0010000 MOV EAX,DWORD PTR DS:[EAX+1F0]  
0042CEA0 E84BCFFEFF CALL KEYME.00419DF0  
0042CEA5 837DD800 CMP DWORD PTR SS:[EBP-28],0  
0042CEA9 750F JNZ SHORT KEYME.0042CEBA  
Si en alguna casilla no se han introducido datos da este mensaje...
0042CEAB B8FCD14200 MOV EAX,KEYME.0042D1FC ; ASCII "Alguna de Las Casillas No Ha Sido Rellenada"
0042CEB0 E817FCFFFF CALL KEYME.0042CACC  
0042CEB5 E918020000 JMP KEYME.0042D0D2  
0042CEBA 8B45EC MOV EAX,DWORD PTR SS:[EBP-14]  
0042CEBD E8C26AFDFF CALL KEYME.00403984  
0042CEC2 E8A998FDFF CALL KEYME.00406770  
0042CEC7 8BF8 MOV EDI,EAX  
0042CEC9 85FF TEST EDI,EDI  
0042CECB 7E4F JLE SHORT KEYME.0042CF1C  
En esta parte el programa empieza buscando desde la primera letra de nuestro nombre hasta la última, si la letra no se encuentra dentro de la palabra clave el programa la elimina de una tercera palabra que formará compuesta por los caracteres de nuestro nombre que aparecen en la cadena clave y valga la redundancia nuestro nombre, por ejemplo las letras "k", "g" y "G" son eliminadas por que no se encuentran en la palabra clave.
0042CECD BE01000000 MOV ESI,1  
0042CED2 8B45F0 MOV EAX,DWORD PTR SS:[EBP-10]  
0042CED5 E8AA6AFDFF CALL KEYME.00403984  
0042CEDA E89198FDFF CALL KEYME.00406770  
0042CEDF 85C0 TEST EAX,EAX  
0042CEE1 7E35 JLE SHORT KEYME.0042CF18  
0042CEE3 BB01000000 MOV EBX,1  
0042CEE8 8B55EC MOV EDX,DWORD PTR SS:[EBP-14]  
0042CEEB 8A5432FF MOV DL,BYTE PTR DS:[EDX+ESI-1]  
0042CEEF 8B4DF0 MOV ECX,DWORD PTR SS:[EBP-10]  
0042CEF2 3A5419FF CMP DL,BYTE PTR DS:[ECX+EBX-1]  
0042CEF6 751C JNZ SHORT KEYME.0042CF14  
0042CEF8 8D45D4 LEA EAX,DWORD PTR SS:[EBP-2C]  
0042CEFB 8B55EC MOV EDX,DWORD PTR SS:[EBP-14]  
0042CEFE 8A5432FF MOV DL,BYTE PTR DS:[EDX+ESI-1]  
0042CF02 E8E167FDFF CALL KEYME.004036E8  
0042CF07 8B55D4 MOV EDX,DWORD PTR SS:[EBP-2C]  
0042CF0A 8D45E8 LEA EAX,DWORD PTR SS:[EBP-18]  
0042CF0D E8B668FDFF CALL KEYME.004037C8  
0042CF12 EB04 JMP SHORT KEYME.0042CF18  
0042CF14 43 INC EBX  
0042CF15 48 DEC EAX  
0042CF16 D0 JNZ SHORT KEYME.0042CEE8  
0042CF18 46 INC ESI  
0042CF19 4F DEC EDI  
0042CF1A B6 JNZ SHORT KEYME.0042CED2  
Aqui termina la creación de la tercera cadena... y empieza la extración de los primeros seis caracteres de la cadena
0042CF1C 8D45E8 LEA EAX,DWORD PTR SS:[EBP-18]  
0042CF1F 8B55F0 MOV EDX,DWORD PTR SS:[EBP-10]  
0042CF22 E8A168FDFF CALL KEYME.004037C8  
0042CF27 8D45EC LEA EAX,DWORD PTR SS:[EBP-14]  
0042CF2A E81566FDFF CALL KEYME.00403544  
0042CF2F BB01000000 MOV EBX,1  
0042CF34 8D45E4 LEA EAX,DWORD PTR SS:[EBP-1C]  
0042CF37 8B55E8 MOV EDX,DWORD PTR SS:[EBP-18]  
0042CF3A 8A541AFF MOV DL,BYTE PTR DS:[EDX+EBX-1]  
0042CF3E E8A567FDFF CALL KEYME.004036E8  
0042CF43 8D45EC LEA EAX,DWORD PTR SS:[EBP-14]  
0042CF46 8B55E4 MOV EDX,DWORD PTR SS:[EBP-1C]  
0042CF49 E87A68FDFF CALL KEYME.004037C8  
0042CF4E 43 INC EBX  
0042CF4F 83FB07 CMP EBX,7  
0042CF52 E0 JNZ SHORT KEYME.0042CF34  
Ya han sido extraídos los primeros seis caracteres de la cadena y ahora el programa va a buscar de acuerdo a los seis caracteres extraídos una unión de caracteres más haciendo algunas operaciones...
0042CF54 8B45EC MOV EAX,DWORD PTR SS:[EBP-14]  
0042CF57 E8286AFDFF CALL KEYME.00403984  
0042CF5C E80F98FDFF CALL KEYME.00406770  
0042CF61 8BF8 MOV EDI,EAX  
0042CF63 85FF TEST EDI,EDI  
0042CF65 7E6C JLE SHORT KEYME.0042CFD3  
0042CF67 BB01000000 MOV EBX,1  
0042CF6C 8B45F0 MOV EAX,DWORD PTR SS:[EBP-10]  
0042CF6F E8106AFDFF CALL KEYME.00403984  
0042CF74 E8F797FDFF CALL KEYME.00406770  
0042CF79 85C0 TEST EAX,EAX  
0042CF7B 7E52 JLE SHORT KEYME.0042CFCF  
0042CF7D BE01000000 MOV ESI,1   <= ESI recibe el valor 1  
0042CF82 8B55EC MOV EDX,DWORD PTR SS:[EBP-14]   <= EDX recibe los seis caracteres  
0042CF85 8A541AFF MOV DL,BYTE PTR DS:[EDX+EBX-1]   <= Extrae caracter por caracter  
0042CF89 8B4DF0 MOV ECX,DWORD PTR SS:[EBP-10]   <= ECX recibe la palabra clave  
0042CF8C 3A5431FF CMP DL,BYTE PTR DS:[ECX+ESI-1]   <= Compara los caracteres  
0042CF90 7539 JNZ SHORT KEYME.0042CFCB   <= Si no son iguales continua buscando  
0042CF92 8BCE MOV ECX,ESI   <= ESI es el valor de la posicion en que fue hallado el caracter  
0042CF94 8BC1 MOV EAX,ECX  
0042CF96 F7E9 IMUL ECX   <= EAX = EAX * ECX  
0042CF98 8BC8 MOV ECX,EAX  
0042CF9A 2BCE SUB ECX,ESI   <= ECX = ECX - ESI  
0042CF9C 034DE0 ADD ECX,DWORD PTR SS:[EBP-20]   <= Suma el valor de EBP-20  
0042CF9F 8BC1 MOV EAX,ECX  
0042CFA1 B936000000 MOV ECX,36  
0042CFA6 99 CDQ  
0042CFA7 F7F9 IDIV ECX   <= El cociente de dividir ECX dentro de EAX es almacenado en EDX  
0042CFA9 8BF2 MOV ESI,EDX   <= ESI recibe el valor  
0042CFAB 46 INC ESI   <= Incrementa uno  
0042CFAC 8D45D4 LEA EAX,DWORD PTR SS:[EBP-2C]  
0042CFAF 8B55F0 MOV EDX,DWORD PTR SS:[EBP-10]   <= EDX recibe palabra clave  
0042CFB2 8A5432FF MOV DL,BYTE PTR DS:[EDX+ESI-1]   <= Extrae el caracter de la posicion que indique ESI-1  
0042CFB6 E82D67FDFF CALL KEYME.004036E8  
0042CFBB 8B55D4 MOV EDX,DWORD PTR SS:[EBP-2C]  
0042CFBE 8D45FC LEA EAX,DWORD PTR SS:[EBP-4]  
0042CFC1 E80268FDFF CALL KEYME.004037C8  
0042CFC6 8975E0 MOV DWORD PTR SS:[EBP-20],ESI  
0042CFC9 EB04 JMP SHORT KEYME.0042CFCF  
0042CFCB 46 INC ESI  
0042CFCC 48 DEC EAX  
0042CFCD B3 JNZ SHORT KEYME.0042CF82  
0042CFCF 43 INC EBX  
0042CFD0 4F DEC EDI  
0042CFD1 99 JNZ SHORT KEYME.0042CF6C   <= Si no ha terminado la cadena regresa a 0042CF6C  
0042CFD3 8D45E8 LEA EAX,DWORD PTR SS:[EBP-18]  
0042CFD6 E86965FDFF CALL KEYME.00403544  
0042CFDB BB01000000 MOV EBX,1  
0042CFE0 83FB07 CMP EBX,7  
0042CFE3 750D JNZ SHORT KEYME.0042CFF2  
0042CFE5 8D45E8 LEA EAX,DWORD PTR SS:[EBP-18]  
0042CFE8 BA30D24200 MOV EDX,KEYME.0042D230  
0042CFED E8D667FDFF CALL KEYME.004037C8  
0042CFF2 8D45D4 LEA EAX,DWORD PTR SS:[EBP-2C]  
0042CFF5 8B55FC MOV EDX,DWORD PTR SS:[EBP-4]   <= EDX recibe la cadena formada anteriormente (Está compuesta de 6 caracteres, no debe confudirse con la primera de 6 caracteres)  
0042CFF8 8A541AFF MOV DL,BYTE PTR DS:[EDX+EBX-1]  
0042CFFC E8E766FDFF CALL KEYME.004036E8  
0042D001 8B55D4 MOV EDX,DWORD PTR SS:[EBP-2C]  
0042D004 8D45E8 LEA EAX,DWORD PTR SS:[EBP-18]  
0042D007 E8BC67FDFF CALL KEYME.004037C8  
0042D00C 43 INC EBX  
0042D00D 83FB07 CMP EBX,7  
0042D010 CE JNZ SHORT KEYME.0042CFE0  
Ahora el programa extraerá letra por letra para formar un valor...
0042D012 8B45EC MOV EAX,DWORD PTR SS:[EBP-14]   <= EAX recibe la primer cadena de 6 caracteres  
0042D015 E86A69FDFF CALL KEYME.00403984  
0042D01A E85197FDFF CALL KEYME.00406770  
0042D01F 8BF8 MOV EDI,EAX  
0042D021 85FF TEST EDI,EDI  
0042D023 7E14 JLE SHORT KEYME.0042D039  
0042D025 BB01000000 MOV EBX,1   <= EBX recibe el valor de 1  
0042D02A 8B45EC MOV EAX,DWORD PTR SS:[EBP-14]   <= EAX recibe el valor de la primera cadena de 6 caracteres  
0042D02D 0FB67418FF MOVZX ESI,BYTE PTR DS:[EAX+EBX-1]   <= Extrae caracter por caracter  
0042D032 0175F8 ADD DWORD PTR SS:[EBP-8],ESI   <= Suma el valor decimal del caracter a EBP-8 que tiene como valor inicial 1  
0042D035 43 INC EBX   <= Incrementa EBX  
0042D036 4F DEC EDI   <= Decrece EDI  
0042D037 F1 JNZ SHORT KEYME.0042D02A   <= Vamos el segundo,tercero,cuarto,etc...  
0042D039 6945F87B2B0100 IMUL EAX,DWORD PTR SS:[EBP-8],12B7B   <= EAX = EBP-8 * 12B7B  
0042D040 8945F8 MOV DWORD PTR SS:[EBP-8],EAX   <= EAX tiene el valor en Hexa de el primer valor que compone el serial correcto  
0042D043 8D55FC LEA EDX,DWORD PTR SS:[EBP-4]  
0042D046 8B45F8 MOV EAX,DWORD PTR SS:[EBP-8]  
0042D049 E80A95FDFF CALL KEYME.00406558   <= El valor de EAX es trasladado a Decimal  
0042D04E FF75FC PUSH DWORD PTR SS:[EBP-4]  
0042D051 6830D24200 PUSH KEYME.0042D230  
0042D056 FF75E8 PUSH DWORD PTR SS:[EBP-18]  
0042D059 8D45E8 LEA EAX,DWORD PTR SS:[EBP-18]  
0042D05C BA03000000 MOV EDX,3   <= EDX recibe el valor de 3  
0042D061 E81A68FDFF CALL KEYME.00403880   <= Concatena los valores el que se acaba de cambiar a decimal y la segunda cadena de caracteres  
0042D066 8945FC MOV DWORD PTR SS:[EBP-4],EAX   <= EAX traslada el valor 0042D066 a EBP-4  
Ahora formamos un tercer valor para formar ya en sí lo que es el serial, el cual al final nos quedaría así...

NNNNNNNN-CCCCCC-NNNNNN


A la vista de no hacer de este tutorial un crack rápido, lo que sigue ya les toca a ustedes, si ya sé, este es un crackme, pero esto que significa, significa el que ustedes realmente se quiebren la cabeza, para destriparlo, además para los que conocen assembler este arroz ya se coció...
0042D069 F765F8 MUL DWORD PTR SS:[EBP-8]  
0042D06C F765F8 MUL DWORD PTR SS:[EBP-8]  
0042D06F 8955F8 MOV DWORD PTR SS:[EBP-8],EDX  
0042D072 C16DF805 SHR DWORD PTR SS:[EBP-8],5  
0042D076 FF75E8 PUSH DWORD PTR SS:[EBP-18]  
0042D079 6830D24200 PUSH KEYME.0042D230  
0042D07E 8D55D4 LEA EDX,DWORD PTR SS:[EBP-2C]  
0042D081 8B45F8 MOV EAX,DWORD PTR SS:[EBP-8]  
0042D084 E8CF94FDFF CALL KEYME.00406558   <= Convierte nuestro ultimo valor en Decimal  
0042D089 FF75D4 PUSH DWORD PTR SS:[EBP-2C]  
0042D08C 8D45E8 LEA EAX,DWORD PTR SS:[EBP-18]  
0042D08F BA03000000 MOV EDX,3  
0042D094 E8E767FDFF CALL KEYME.00403880   <= Une todos los valores creando nuestro serial correcto  
0042D099 8D55DC LEA EDX,DWORD PTR SS:[EBP-24]  
0042D09C 8B45F4 MOV EAX,DWORD PTR SS:[EBP-C]  
0042D09F 8B80F0010000 MOV EAX,DWORD PTR DS:[EAX+1F0]  
0042D0A5 E846CDFEFF CALL KEYME.00419DF0  
0042D0AA 8B45DC MOV EAX,DWORD PTR SS:[EBP-24]   <= EAX recibe nuestro serial malo  
0042D0AD 8B55E8 MOV EDX,DWORD PTR SS:[EBP-18]   <= EDX recibe el serial correcto  
0042D0B0 E81B68FDFF CALL KEYME.004038D0   <= Compara EAX y EDX  
0042D0B5 7511 JNZ SHORT KEYME.0042D0C8   <= Si son iguales no vamos a ver el mensaje de error, sino que continuamos al de "Buen Cracker"  
0042D0B7 E8B8AFFDFF CALL KEYME.00408074  
0042D0BC B83CD24200 MOV EAX,KEYME.0042D23C    ; ASCII "Serial Correcto; Buen Cracker"

Ahora ya podemos generar el keygen y aqui tienen el código fuente en MASM32...

-----Inicio de Código-----
.386
.model flat,stdcall
option casemap:none

include c:\masm32\include\windows.inc
include c:\masm32\include\user32.inc
include c:\masm32\include\kernel32.inc
includelib c:\masm32\lib\user32.lib
includelib c:\masm32\lib\kernel32.lib

.const

IDD_DIALOG EQU 100
IDC_NAME EQU 101
IDC_SERIAL EQU 102
IDI_ICON EQU 103
IDC_COPY EQU 200
IDC_INFO EQU 201

DlgFunc PROTO :DWORD,:DWORD,:DWORD,:DWORD
Operacion PROTO
Clipo PROTO hWnd:HWND

.data

nombre db 33 dup(0),0
blank db 10 dup(0),0
clave db
"MUYBIENHASDESCUBIERTOLACONSTANTEPEROTODAVIATEQUEDAPORHACERTOMANUMERITO7894378924978yparacomplicarmasminusculastambienYMASCOSASZXCVBNMÑñ345"
     db "`"
     db "+SA"
     db "`"
     db "+Ç-*/()&&%%$$·"
     db '"'
     db "1![];:~DSHFSDKJFSOIU440KFJDBKSDKSFDSOIFE8983493KFLJNV",0
serial db "0123456789",0
serial1 db 40 dup(0),0
serial2 db "0123456789",0
cadena db 33 dup(0),0
separa db "-",0
mifmt db "%lu",0
minombre db "ByTESCRK",0
aboutcap db "Crack-KeyGen-ME v1.0",0
abouttxt db "Keygen por ByTESCRK",13,10
     db "bytescrk@",13,10,13,10
     db "Cracked [RAZiEL] :)",13,10,13,10
     db "http://granavenida.com/kfor",0
minchar db "¡Mínimo 1 caracter!",0
hInstance dd 0
hIcon dd 0
buff db 256 dup(?)
hWnd HWND ?

.code

start:

invoke GetModuleHandle,NULL
mov hInstance,eax
invoke DialogBoxParam,hInstance,IDD_DIALOG,NULL,addr DlgFunc,NULL
invoke ExitProcess,NULL

DlgFunc proc hDlg:DWORD,uMsg:DWORD,wParam:DWORD,lParam:DWORD

.if uMsg==WM_INITDIALOG
     mov eax,hDlg
     mov hWnd,eax
     invoke LoadIcon,hInstance,IDI_ICON
     mov hIcon,eax
     invoke SendMessage, hDlg, WM_SETICON,1,hIcon
     invoke SendDlgItemMessageA,hWnd,IDC_NAME,EM_LIMITTEXT,32,NULL
     invoke SetWindowText,hDlg,ADDR aboutcap
     invoke SetDlgItemText,hDlg,IDC_NAME,ADDR minombre
.elseif uMsg==WM_CLOSE
     invoke EndDialog,hDlg,NULL
.elseif uMsg==WM_COMMAND
     mov eax,wParam
     .if ax==IDC_NAME
       shr eax,16
       .if ax==EN_CHANGE
         invoke GetDlgItemTextA,hDlg,IDC_NAME,ADDR nombre,33
         invoke lstrlen,ADDR nombre
         .if eax==0
           invoke SetDlgItemTextA,hDlg,IDC_SERIAL,ADDR blank
         .else
           invoke Operacion
         .if eax==0
           invoke SetDlgItemTextA,hDlg,IDC_SERIAL,ADDR minchar
         .elseif eax==6666
           invoke SetDlgItemText,hDlg,IDC_NAME,ADDR nombre
         .else
           invoke SetDlgItemTextA,hDlg,IDC_SERIAL,ADDR serial
         .endif
       .endif
     xor eax, eax
     ret
     .endif
     .endif
     mov edx,eax
     shr edx,16
     .if dx==BN_CLICKED
     .if ax==IDC_COPY
       invoke Clipo,hDlg
       xor eax,eax
       ret
     .elseif ax==IDC_INFO
       invoke MessageBoxA, hDlg, offset abouttxt, offset aboutcap, NULL
       xor eax,eax
       ret
         .endif
     .endif
.endif
xor eax,eax
ret

DlgFunc endp

Operacion proc

pushad

     invoke lstrlen,offset nombre
     .if eax < 0
         popad
         mov eax,1
         ret
     .endif

     mov esi,offset serial
     mov dword ptr[esi],33323130h
     add esi,4
     mov dword ptr[esi],37363534h
     add esi,4
     mov dword ptr[esi],3938h

     mov esi,offset serial2
     mov dword ptr[esi],33323130h
     add esi,4
     mov dword ptr[esi],37363534h
     add esi,4
     mov dword ptr[esi],3938h

     mov edx,offset clave
     mov ebx,1
     mov edi,1
     invoke lstrlen,offset nombre
     push ebp
     mov ebp,eax

StepO:     mov esi,offset nombre
     movsx eax,byte ptr[esi+ebx-1]
StepN:     movsx ecx,byte ptr[edx+edi-1]
         .if eax==ecx
         mov ecx,offset cadena
         mov esi,eax
         invoke lstrlen,ecx
         .if eax > 0
             add ecx,eax
         .endif
         mov dword ptr[ecx],esi
         .else
             inc edi
             cmp edi,000000d4h
             jne StepN
         .endif
         mov edi,1
         inc ebx
         invoke lstrlen,offset nombre
         inc eax
         cmp ebx,eax
         jne StepO

         invoke lstrlen,offset cadena
         .if eax > 6
             jmp siga
         .endif
         mov edi,1
         mov esi,offset cadena

fill:     mov ecx,offset clave
         movsx ebx,byte ptr[ecx+edi-1]
         invoke lstrlen,esi
         .if eax > 0
             add esi,eax
         .endif
         mov dword ptr [esi],ebx
         invoke lstrlen,offset cadena
         .if eax < 6
             inc edi
             jmp fill
         .endif

siga:
         pop ebp
         xor esi,esi
         mov dword ptr[EBP-020h],esi
         mov ebx,offset cadena
         mov esi,1
Step1:
         mov edx,offset clave
         mov al,byte ptr[ebx]
         cmp al,byte ptr[edx+esi-1]
         jne EndA

         MOV ECX,ESI
         MOV EAX,ECX
         IMUL ECX
         MOV ECX,EAX
         SUB ECX,ESI
         ADD ECX,DWORD PTR [EBP-020h]
         MOV EAX,ECX
         MOV ECX,000000036h
         CDQ
         IDIV ECX
         MOV ESI,EDX
         INC ESI
         INC EBX
         MOV EDX,offset clave
         MOV DWORD PTR [EBP-020h],ESI
         MOVSX ECX,BYTE PTR[EDX+ESI-1]
         mov esi,offset serial1
         invoke lstrlen,esi
         .if eax > 0
             add esi,eax
         .endif
         .if eax == 6
             MOV EBX,1
             MOV DWORD PTR[EBP-8],EBX
             jmp Step2
         .endif
         mov dword ptr[esi],ecx
         MOV ESI,1
         JMP Step1
EndA:
         INC ESI
         jmp Step1

Step2:     MOV EAX,offset cadena
         MOVZX ESI,BYTE PTR DS:[EAX+EBX-1]
         ADD DWORD PTR [EBP-8],ESI
         INC EBX
         cmp ebx,7
         JNE Step2
         IMUL EAX,DWORD PTR [EBP-8],12B7Bh
         mov esi,offset serial
         invoke wsprintfA,esi,ADDR mifmt,eax
         MOV EBX,1
         MOV DWORD PTR[EBP-8],EBX

Step3:     MOV EAX,offset cadena
         MOVZX ESI,BYTE PTR DS:[EAX+EBX-1]
         ADD DWORD PTR [EBP-8],ESI
         INC EBX
         cmp ebx,7
         JNE Step3
         IMUL EAX,DWORD PTR [EBP-8],12B7Bh
         XOR ECX,ECX
         MOV DWORD PTR [EBP-8],EAX
         MOV EAX,42D066h
         MOV EDX,3
         MUL DWORD PTR [EBP-8]
         MUL DWORD PTR [EBP-8]
         MOV DWORD PTR [EBP-8],EDX
         SHR DWORD PTR [EBP-8],5
         mov eax, dword ptr [EBP-8]
         mov esi,offset serial2
         invoke wsprintfA,esi,ADDR mifmt,eax

         invoke lstrcat,offset serial,offset separa
         invoke lstrcat,offset serial1,offset separa
         invoke lstrcat,offset serial1,offset serial2
         invoke lstrcat,offset serial,offset serial1

         popad
         ret

Operacion endp

Clipo proc hDlg:DWORD
         LOCAL gmem :DWORD

         invoke GlobalAlloc,GMEM_MOVEABLE+GMEM_DDESHARE,254
         mov gmem,eax

         invoke GlobalLock,eax
         cmp eax,NULL
         je noabra
         mov ebx,offset serial
         lea esi,dword ptr[ebx]
         mov edi,eax
         mov ecx,29

         rep movsb

         invoke OpenClipboard,hDlg
         cmp eax,TRUE
         jne noabra2

         mov eax,gmem
         invoke SetClipboardData,CF_TEXT, eax

         invoke CloseClipboard

noabra2:
         mov eax,gmem
         invoke GlobalFree,eax

noabra:
         ret
Clipo endp

end start
-----Final de Código-----

Cool! ;)


"EL motivo de este tutorial es solo con el fin de conocer la seguridad en ciertos programas de manera educacional y tambien como diversión, aunque como RAZiEL nos dice que podemos hacer y deshacer con el programa, realmente yo tambien los invito a hacerlo ;o)"

Y así doy por concluído mi 15avo tutorial, saludando a mis buenos amigos Karpoff, Pr@fesor_X, CaoS ReptantE, [Kalisto (okaruzic) "Salute"] y a todos los crackers hispanohablantes.

Si tienes alguna duda o comentario escríbeme a: ByTESCRK@iespana.es

ByTESCRK
 

 

 

Karpoff Spanish Tutor: Pagina dedicada a la divulgacion de informacion en Castellano, sobre Ingenieria Inversa y Programacion. Email "Colabora con tus Proyectos"
www.000webhost.com