Karpoff Spanish Tutor 1999-2001

Programa:

Coloristic v1.2


 

PROTECCION: Serial
PROPOSITO: Sacar serial y hacer un KeyGen
Descripcion: Coloristic es una simple utilería la cual agranda el área de la pantalla en donde está el cursor y nos permite ver el color de un pixel específico en diferentes formatos.
Dificultad: Novato.
DOWNLOAD: Bubble Pop Software
Herramientas: TRW2000, W32dasm
CRACKER: ByTESCRK   FECHA: 23/08/2001

 

 INTRODUCCION

Hace algún tiempo necesité saber cuales eran los colores de algunas gráficas, necesitaba estar viendo las páginas y el color que representaba, este programa me ayudó mucho. Bueno, ¿como han estado?, desde mi primer tutorial que ya no escribía otro, ahora después de haber solventado problema con el notepad, estoy de vuelta. Aqui les pego la descripción completa:

"Coloristic is a simple utility which magnifies the area of the screen surrounding the cursor. It will also display the color value for the pixel that is exactly under the cursor and allow you to copy that color value to the clipboard. In addition, you can measure the distance between any two pixels on screen, and save the magnified image to a file or the clipboard."

 

 AL ATAKE


Lo primero es lo primero, abrimos el programa y vemos que nos aparece una caja de texto que nos recuerda que debemos de registrarnos, hacemos clic en Register... y nos aparece otra, ahora ingresemos un nombre y código cualquiera, yo ingresé este "ByTESCRK" y "1234", nos saldrá otra ventanita que nos dice que no tenemos un serial válido. Nuestro propósito es hacer un Keygen, cerramos el programa y nos vamos a desensamblarlo con el W32DASM, cuando ya lo tengamos, vamos a buscar la String Reference del mensaje de error que nos salió en la última ventanita, osease esta
"You have entered an invalid registration code. Please contac..."

Hacemos doble clic sobre ella y caemos en este lugar...

:00403C69 E832360000                     call 004072A0
:00403C6E EB2A                                jmp 00403C9A

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00403C26(C)          Tenemos que investigar aquí
|

* Possible Ref to Menu: MenuID_0064, Item: "Register..."
|

* Possible Reference to String Resource ID=00501: "You have entered an invalid registration code. Please contac"
|
:00403C70 68F5010000                push 000001F5      Caemos aqui
:00403C75 8D45F8                       lea eax, dword ptr [ebp-08]
:00403C78 50                                push eax

Vamos a ir ahora al botón del W32DASM llamado Goto Code Location y nos vamos a ir a la referencia de arriba que sería la dirección 00403C26 (marcada en rojo), caemos en ella y empezamos a ver nuestros alrededores y vemos que es un salto condicional je, veamos el código y analicémoslo...

:00403C13 50                              push eax
:00403C14 8B4D9C                    mov ecx, dword ptr [ebp-64]
:00403C17 E8E41C0000             call 00405900      Esta es la Call que genera el serial correcto
:00403C1C 8B459C                    mov eax, dword ptr [ebp-64]      El valor 0 ó 1 lo guarda en EAX
:00403C1F 83B8D800000000    cmp dword ptr [eax+000000D8], 00000000      Compara EAX no igual a 0
:00403C26 7448                          je 00403C70     Si EAX igual 0 entonces ir a 00403C70

* Possible Ref to Menu: MenuID_0064, Item: "About Coloristic"

* Possible Reference to String Resource ID=00500: "Thank you for registering your copy of Coloristic ..."

:00403C28 68F4010000                push 000001F4
:00403C2D 8D45F0                      lea eax, dword ptr [ebp-10]
:00403C30 50                                push eax

Hagamos clic en el botón CALL de la barra de herramientas de W32DASM y caemos en este punto, vemos que la direción es 00405900, cargamos el TRW2000 y buscamos el programa coloristic.exe haciendo clic en browse, hacemos clic en load y nos aparece el punto de entrada del programa, ctrl+n y cerramos la ventana, vamos a Help > Register... e ingresamos nuestros datos en mi caso ya los dije, ponemos un punto de ruptura (Breakpoint) en 405900, volvemos al programa y al hacer clic en Register, salta el TRW2000, y

:00405900 55                                push ebp      Caemos aqui
:00405901 89E5                            mov ebp, esp
:00405903 53                                push ebx
:00405904 56                                push esi
:00405905 81EC30010000           sub esp, 00000130
:0040590B 898DC8FEFFFF         mov dword ptr [ebp+FFFFFEC8], ecx
:00405911 8B4508                        mov eax, dword ptr [ebp+08]
:00405914 8B5004                        mov edx, dword ptr [eax+04]      EDX recibe el valor de la longitud del nombre
:00405917 8995CCFEFFFF         mov dword ptr [ebp+FFFFFECC], edx
:0040591D 8B1510F04200           mov edx, dword ptr [0042F010]      Un valor 10 como constante
:00405923 8995D0FEFFFF          mov dword ptr [ebp+FFFFFED0], edx
:00405929 83BDCCFEFFFF01    cmp dword ptr [ebp+FFFFFECC], 00000001
:00405930 7C09                            jl 0040593B
:00405932 83BDD0FEFFFF01     cmp dword ptr [ebp+FFFFFED0], 00000001
:00405939 7D19                            jge 00405954      Vamos a 00405954

:00405954 8B4508                        mov eax, dword ptr [ebp+08]      EAX = Nuestro nombre
:00405957 8B00                            mov eax, dword ptr [eax]
:00405959 40                                 inc eax
:0040595A 50                                push eax
:0040595B 8D85F4FEFFFF          lea eax, dword ptr [ebp+FFFFFEF4]
:00405961 50                                 push eax
:00405962 E8B9270000                call 00408120      Crea una lista de caracteres con el nombre
:00405967 59                                 pop ecx      Recibe nuestro nombre
:00405968 59                                 pop ecx
:00405969 8B85CCFEFFFF          mov eax, dword ptr [ebp+FFFFFECC]
:0040596F 3B85D0FEFFFF          cmp eax, dword ptr [ebp+FFFFFED0]
:00405975 7D09                             jge 00405980
:00405977 8B95CCFEFFFF          mov edx, dword ptr [ebp+FFFFFECC]
:0040597D EB07                            jmp 00405986
:0040597F 90                                 nop
:00405980 8B95D0FEFFFF           mov edx, dword ptr [ebp+FFFFFED0]
:00405986 8995D4FEFFFF           mov dword ptr [ebp+FFFFFED4], edx
:0040598C C785D8FEFFFF00000000      mov dword ptr [ebp+FFFFFED8], 00000000
:00405996 EB23                            jmp 004059BB      Pone EAX a 0 y crea una lista por medio de una palabra clave, la cual servirá adelante, sale y va a 00405A3F

***El código que continuaba fué omitido adrede para no mostrar la palabra secreta que es la base para la generación del serial correcto, el siguiente código es la continuación después de salir de la rutina de la palabra secreta***
@j@ Esta es la rutina de generación del serial correcto

:004059E0 8B9DCCFEFFFF           mov ebx, dword ptr [ebp+FFFFFECC]      Longitud del nombre
:004059E6 2B9DD0FEFFFF            sub ebx, dword ptr [ebp+FFFFFED0]      EBX=Constante 10 - Longitud del nombre
:004059EC 8B85E0FEFFFF             mov eax, dword ptr [ebp+FFFFFEE0]      EAX = 0 en cada vuelta sumara 1 a EAX
:004059F2 0FB69405F4FEFFFF     movzx edx, byte ptr [ebp+eax-0000010C]      Ir aqui para ver Nota 1
:004059FA 0395E0FEFFFF              add edx, dword ptr [ebp+FFFFFEE0]     Sumara el valor de EAX
:00405A00 01D3                               add ebx, edx      EBX=EBX+EDX
:00405A02 899DE4FEFFFF             mov dword ptr [ebp+FFFFFEE4], ebx      Mueve el resultado, servirá adelante
:00405A08 8B8DE4FEFFFF            mov ecx, dword ptr [ebp+FFFFFEE4]
:00405A0E D1E1                               shl ecx, 1      ECX=ECX*2
:00405A10 8B95E4FEFFFF              mov edx, dword ptr [ebp+FFFFFEE4]      Recupera el valor de EBX anterior
:00405A16 D1EA                               shr edx, 1      Divide el valor entre 2 y saca el entero
:00405A18 01D1                               add ecx, edx      ECX=ECX+EDX
:00405A1A 038DD4FEFFFF            add ecx, dword ptr [ebp+FFFFFED4]      Suma a ECX la longitud del nombre
:00405A20 898DE8FEFFFF              mov dword ptr [ebp+FFFFFEE8], ecx
:00405A26 8B95E4FEFFFF             mov edx, dword ptr [ebp+FFFFFEE4]      Recupera el valor de EBX
:00405A2C 0FAF95E8FEFFFF          imul edx, dword ptr [ebp+FFFFFEE8]      EDX=EDX*ECX
:00405A33 0195DCFEFFFF             add dword ptr [ebp+FFFFFEDC], edx      Acumula el valor de EDX
:00405A39 FF85E0FEFFFF             inc dword ptr [ebp+FFFFFEE0]      Incrementa uno a EAX
:00405A3F 8B85E0FEFFFF             mov eax, dword ptr [ebp+FFFFFEE0]
:00405A45 3B85CCFEFFFF             cmp eax, dword ptr [ebp+FFFFFECC]
:00405A4B 7C93                              jl 004059E0      Compara si valor es menor no salta
:00405A4D 8B85DCFEFFFF             mov eax, dword ptr [ebp+FFFFFEDC]      EAX recibe el acumulado total
:00405A53 31D2                               xor edx, edx EDX=0
:00405A55 F7B5D0FEFFFF               div dword ptr [ebp+FFFFFED0]      Ver Nota 2 aqui
:00405A5B 89D2                              mov edx, edx
:00405A5D 8995ECFEFFFF             mov dword ptr [ebp+FFFFFEEC], edx      
Ver Nota 3 aqui
:00405A63 8BB5ECFEFFFF             mov esi, dword ptr [ebp+FFFFFEEC]
:00405A69 46                                    inc esi
:00405A6A 8B1D0CF04200              mov ebx, dword ptr [0042F00C]
:00405A70 8A1433                           mov dl, byte ptr [ebx+esi]
:00405A73 8895F0FEFFFF              mov byte ptr [ebp+FFFFFEF0], dl
:00405A79 FFB5DCFEFFFF             push dword ptr [ebp+FFFFFEDC]
:00405A7F 0FBE85F0FEFFFF            movsx eax, byte ptr [ebp+FFFFFEF0]
:00405A86 50                                     push eax
:00405A87 68EA524100                    push 004152EA
:00405A8C 8D85F4FEFFFF                  lea eax, dword ptr [ebp+FFFFFEF4]
:00405A92 50                                     push eax
:00405A93 E868490000                     call 0040A400
:00405A98 83C410                               add esp, 00000010        Aqui si solicitamos D ESP ya podemos ver nuestro serial




Nota 1: Extrae caracteres de acuerdo a la longitud del nombre, primero el 1, luego el 2, etc. aqui se utiliza la palabra secreta, el valor devuelto es decimal y es la suma de cada caracter en orden desde el primer caracter de cada palabra (la secreta y nuestro nombre)

Nota 2: Extrae el caracter en la última posición de EAX, lo devuelve a EDX

Nota 3: Extrae el caracter de la posición devuelta a EDX de la palabra secreta



Modulo de generación del serial programado en Visual Basic
Private Sub Command1_Click()
      minombre = Trim(Text1.Text)
     miserial = 0
     clave = "COLOQUE AQUI LA PALABRA CLAVE"
     largo = Len(minombre)
If largo < 10 Then
     falta = 10 - largo
Else
     faltan = largo - 10
End If
If largo > 10 Then
     largo1 = 10
Else
     largo1 = largo
End If
For i = 1 To largo1
     charac1 = Asc(Mid(minombre, i, 1))
     charac2 = Asc(Mid(clave, i, 1))
      Charac3 = charac1 + charac2
      minombre1 = minombre1 + Chr(Charac3)
Next
If Len(minombre) > 10 Then
      minombre = minombre1 + Mid(minombre, 11, (Len(minombre) - 10))
Else
      minombre = minombre1
End If
For i = 1 To Len(Trim(minombre))
      edx = Asc(Mid(minombre, i, 1))
      edx = edx + (i - 1)
      ebx = edx - falta
      ecx = ebx * 2
      edx = Int(ebx / 2)
      ecx = ecx + edx
      ecx = ecx + largo
      edx = ebx * ecx
      miserial = miserial + edx
Next
      LETRA = Mid(Trim(Str(miserial)), Len(Trim(Str(miserial))), 1) + 1
      LETRA = Mid(clave, LETRA, 1)
      Text2.Text = LETRA + Trim(Str(miserial))
End Sub


Eso es todo, ahora ya hemos generado nuestro propio serial o nuestro keygen, antes que nada no está demás decirles que

"Si les gusta el programa paguen por él"

No me responsabilizo por el mal uso de este tutorial, el fin principal es "Aprender Más".

Ahora quiero saludar a nuestro buen amigo Karpoff que es quien nos apoya en este arte de enseñar, así tambien a CaoS_ReptantE puesto que sin su ayuda desinteresada este tutorial no hubiese sido posible, gracias tambien a Act_MagO por algunas cosillas.

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