Karpoff Spanish Tutor 1999-2001

Programa:

WebScope v3.8a


 

PROTECCION: Name / Serial, Limitación de Tiempo
Objetivo: Hacer un Keygen
Descripcion: Excelente programa en español para la creación de páginas Web
Dificultad: Aficionado.
DOWNLOAD: WebScope v3.8a
Herramientas: TRW2000, OllyDBG, W32dasm y Gran Paciencia :D
CRACKER: ByTESCRK   FECHA: 12/10/2001

 

 INTRODUCCION

Creo que esto (séptimo tutorial) no hubiese sido posible, sino es por el ánimo que en su oportunidad me diera mi buen amigo CaoS ReptantE.

Este es un programa que me traía pensando desde hace mucho tiempo, CaoS me dijo "el número o el algoritmo para calcularlo debe estar necesariamente en el programa", esto debido a que me imaginaba que era algo externo del programa. Y por decirlo así ya verán a lo que me refiero.

Cuando desensamblemos el programa en W32DASM podemos ver en las Reference Strings la cadena \\.\SICE esto nos indica que si tenemos el SoftIce instalado, el programa no se ejecutará, pero podemos hacer uso del FrogSice, para que el programa si se ejecute, puesto que tambien tiene una rutina de CRC-Protection, lo que quiere decir que si parchamos el programa salta esta rutina, tambien encontraremos la referencia a otro programa \\.\NTICE (aún no lo conozco).

 

 AL ATAKE

Empecemos, carguemos el programa aparece una ventanita para registrarnos, hacemos clic en Registrar y aparecen nuestros viejos amigos, las cajitas de Nombre de Usuario y de Serial ingresamos nuestros valores

Nombre de Usuario: ByTESCRK
Serial: 19970424


Y nos da el mensajito de error...

"El nombre de usuario o la clave introducida no son válidos.
Verifica que los datos que introduces están correctamente
escritos, tal y como aparecen en la información de registro."


Cerramos el programa y vamos a desensamblar con W32DASM y buscamos esta cadena en las Reference Strings, al hallarla vemos lo siguiente

:005424EE E9F513ECFF jmp 004038E8
:005424F3 EBE8 jmp 005424DD

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00542450(C)    <= Vamos a investigar aqui
|
:005424F5 6A30 push 00000030

* Possible StringData Ref from Code Obj ->"Error"
|
:005424F7 B9C4255400 mov ecx, 005425C4

* Possible StringData Ref from Code Obj ->"El nombre de usuario o la clave "
->"introducida no son v"
|
:005424FC BACC255400 mov edx, 005425CC    <= Caemos aqui
:00542501 A1E0385900 mov eax, dword ptr [005938E0]
:00542506 8B00 mov eax, dword ptr [eax]
:00542508 E8C73FF1FF call 004564D4


Ahora cargamos el programa TRW2000 y cargamos el programa con LOAD, ponemos un punto de ruptura en 00542449 (bpx 00542449), Ctrl + N para continuar con la ejecución del programa, nos aparece nuevamente la ventanita y volvemos a ingresar nuestros valores y hacemos clic en OK automáticamente salta TRW y caemos en...

:00542445 8B45F8 mov eax, dword ptr [ebp-08]
:00542448 59 pop ecx
:00542449 E8FEF7FFFF call 00541C4C    <= Vamos a entrar aqui
:0054244E 84C0 test al, al
:00542450 0F849F000000 je 005424F5

* Possible StringData Ref from Code Obj ->"Software\Sarovi\WebScope"
|
:00542456 B984255400 mov ecx, 00542584
:0054245B B201 mov dl, 01
:0054245D A1DC824500 mov eax, dword ptr [004582DC]
:00542462 E8E969F1FF call 00458E50

Al entrar en la llamada encontramos esto...

:00541C4C 55 push ebp
:00541C4D 8BEC mov ebp, esp
:00541C4F 83C4F4 add esp, FFFFFFF4
:00541C52 53 push ebx
:00541C53 56 push esi
:00541C54 33DB xor ebx, ebx
:00541C56 895DF4 mov dword ptr [ebp-0C], ebx
:00541C59 894DF8 mov dword ptr [ebp-08], ecx
:00541C5C 8955FC mov dword ptr [ebp-04], edx
:00541C5F 8BF0 mov esi, eax
:00541C61 8B45FC mov eax, dword ptr [ebp-04]
:00541C64 E89F26ECFF call 00404308
:00541C69 8B45F8 mov eax, dword ptr [ebp-08]
:00541C6C E89726ECFF call 00404308
:00541C71 33C0 xor eax, eax
:00541C73 55 push ebp
:00541C74 68751D5400 push 00541D75
:00541C79 64FF30 push dword ptr fs:[eax]
:00541C7C 648920 mov dword ptr fs:[eax], esp
:00541C7F 33DB xor ebx, ebx
:00541C81 8B45FC mov eax, dword ptr [ebp-04]
:00541C84 E8CB24ECFF call 00404154    <= Cuenta los caracteres del serial
:00541C89 83F80D cmp eax, 0000000D    <= Compara que nuestro serial sea mayor que 13 letras
:00541C8C 0F8CC8000000 jl 00541D5A    <= Si es menor busca la salida y da chicomalo
:00541C92 8D4608 lea eax, dword ptr [esi+08]
:00541C95 50 push eax
:00541C96 B904000000 mov ecx, 00000004
:00541C9B BA01000000 mov edx, 00000001
:00541CA0 8B45FC mov eax, dword ptr [ebp-04]
:00541CA3 E8B426ECFF call 0040435C
:00541CA8 8D460C lea eax, dword ptr [esi+0C]
:00541CAB 50 push eax
:00541CAC B902000000 mov ecx, 00000002
:00541CB1 BA05000000 mov edx, 00000005
:00541CB6 8B45FC mov eax, dword ptr [ebp-04]
:00541CB9 E89E26ECFF call 0040435C
:00541CBE 8B45FC mov eax, dword ptr [ebp-04]
:00541CC1 8A4006 mov al, byte ptr [eax+06]    <= Extrae el séptimo caracter
:00541CC4 25FF000000 and eax, 000000FF
:00541CC9 83C0CF add eax, FFFFFFCF    <= Suma EAX = EAX - 31h
:00541CCC 83F806 cmp eax, 00000006    <= Compara que el valor esté entre 1 y 6
:00541CCF 0F8785000000 ja 00541D5A    <= Si el valor resultante no esta entre 1 y 6 sale
:00541CD5 FF2485DC1C5400 jmp dword ptr [4*eax+00541CDC]    <= Va dependiendo del valor

:00541CF8 C6461000 mov [esi+10], 00    <= Si es cero llega aqui
:00541CFC EB22 jmp 00541D20    <= Vamos a 00541D20
:00541CFE C6461001 mov [esi+10], 01    <= Si es uno llega aqui
:00541D02 EB1C jmp 00541D20
:00541D04 C6461002 mov [esi+10], 02    <= etc.
:00541D08 EB16 jmp 00541D20
:00541D0A C6461003 mov [esi+10], 03
:00541D0E EB10 jmp 00541D20
:00541D10 C6461004 mov [esi+10], 04
:00541D14 EB0A jmp 00541D20
:00541D16 C6461005 mov [esi+10], 05
:00541D1A EB04 jmp 00541D20
:00541D1C C6461006 mov [esi+10], 06

:00541D20 8D4614 lea eax, dword ptr [esi+14]    <= Aqui caemos
:00541D23 50 push eax
:00541D24 B905000000 mov ecx, 00000005
:00541D29 BA08000000 mov edx, 00000008
:00541D2E 8B45FC mov eax, dword ptr [ebp-04]
:00541D31 E82626ECFF call 0040435C
:00541D36 8D4618 lea eax, dword ptr [esi+18]
:00541D39 8B55F8 mov edx, dword ptr [ebp-08]
:00541D3C E8E721ECFF call 00403F28
:00541D41 8D55F4 lea edx, dword ptr [ebp-0C]
:00541D44 8BC6 mov eax, esi
:00541D46 E825FEFFFF call 00541B70    <= Calcula el serial, nosotros entramos
:00541D4B 8B55F4 mov edx, dword ptr [ebp-0C]    <= Serial del programa
:00541D4E 8B45FC mov eax, dword ptr [ebp-04]    <= Serial malo
:00541D51 E80E25ECFF call 00404264    <= Compara el serial
:00541D56 7502 jne 00541D5A    <= Si no son iguales sale y error!
:00541D58 B301 mov bl, 01
:00541D5A 33C0 xor eax, eax
:00541D5C 5A pop edx
:00541D5D 59 pop ecx
:00541D5E 59 pop ecx
:00541D5F 648910 mov dword ptr fs:[eax], edx
:00541D62 687C1D5400 push 00541D7C
:00541D67 8D45F4 lea eax, dword ptr [ebp-0C]
:00541D6A BA03000000 mov edx, 00000003
:00541D6F E88421ECFF call 00403EF8
:00541D74 C3 ret

Adentro de la rutina vemos esto...

:00541B70 55 push ebp
:00541B71 8BEC mov ebp, esp
:00541B73 83C4C8 add esp, FFFFFFC8
:00541B76 53 push ebx
:00541B77 56 push esi
:00541B78 33C9 xor ecx, ecx
:00541B7A 894DC8 mov dword ptr [ebp-38], ecx
:00541B7D 8955FC mov dword ptr [ebp-04], edx
:00541B80 8BD8 mov ebx, eax
:00541B82 33C0 xor eax, eax
:00541B84 55 push ebp
:00541B85 68241C5400 push 00541C24
:00541B8A 64FF30 push dword ptr fs:[eax]
:00541B8D 648920 mov dword ptr fs:[eax], esp
:00541B90 BE01000000 mov esi, 00000001    <= ESI recibe el valor de 1
:00541B95 8B4318 mov eax, dword ptr [ebx+18]    <= Nuestro nombre
:00541B98 E8B725ECFF call 00404154    <= Cuenta las letras
:00541B9D 83F801 cmp eax, 00000001    <= Compara con 1
:00541BA0 7C0F jl 00541BB1    <= Si es blanco da error
:00541BA2 8B5318 mov edx, dword ptr [ebx+18]    <= Nuestro nombre
:00541BA5 0FB65402FF movzx edx, byte ptr [edx+eax-01]    <= Extrae letra por letra
:00541BAA 03F2 add esi, edx    <= ESI = ESI + EDX (ESI trae 1 la primera vez)
:00541BAC 48 dec eax    <= Decrece EAX en 1
:00541BAD 85C0 test eax, eax    <= Compara
:00541BAF 75F1 jne 00541BA2    <= Si no ha terminado regresa
:00541BB1 8B45FC mov eax, dword ptr [ebp-04]
:00541BB4 50 push eax
:00541BB5 8B4308 mov eax, dword ptr [ebx+08]
:00541BB8 8945CC mov dword ptr [ebp-34], eax
:00541BBB C645D00B mov [ebp-30], 0B
:00541BBF 8B430C mov eax, dword ptr [ebx+0C]
:00541BC2 8945D4 mov dword ptr [ebp-2C], eax
:00541BC5 C645D80B mov [ebp-28], 0B
:00541BC9 8BC3 mov eax, ebx
:00541BCB E86CFEFFFF call 00541A3C
:00541BD0 8845DC mov byte ptr [ebp-24], al
:00541BD3 C645E002 mov [ebp-20], 02
:00541BD7 8B4314 mov eax, dword ptr [ebx+14]
:00541BDA 8945E4 mov dword ptr [ebp-1C], eax
:00541BDD C645E80B mov [ebp-18], 0B
:00541BE1 8975EC mov dword ptr [ebp-14], esi
:00541BE4 C645F000 mov [ebp-10], 00
:00541BE8 8D55C8 lea edx, dword ptr [ebp-38]
:00541BEB 8BC3 mov eax, ebx
:00541BED E88EFEFFFF call 00541A80    <= Entramos aqui

Investigamos en la llamada, dentro de la rutina encontramos lo siguiente...

:00541A80 55 push ebp
:00541A81 8BEC mov ebp, esp
:00541A83 83C4D0 add esp, FFFFFFD0
:00541A86 53 push ebx
:00541A87 56 push esi
:00541A88 33C9 xor ecx, ecx
:00541A8A 894DF8 mov dword ptr [ebp-08], ecx
:00541A8D 8955FC mov dword ptr [ebp-04], edx
:00541A90 8BF0 mov esi, eax
:00541A92 33C0 xor eax, eax
:00541A94 55 push ebp
:00541A95 684F1B5400 push 00541B4F
:00541A9A 64FF30 push dword ptr fs:[eax]
:00541A9D 648920 mov dword ptr fs:[eax], esp
:00541AA0 BB01000000 mov ebx, 00000001    <= EBX recibe el valor de 1
:00541AA5 8B4618 mov eax, dword ptr [esi+18]    <= Nuestro nombre
:00541AA8 E8A726ECFF call 00404154    <= Calcula las letras
:00541AAD 83F801 cmp eax, 00000001    <= Compara con 1
:00541AB0 7C0F jl 00541AC1    <= Si es en blanco da error
:00541AB2 8B5618 mov edx, dword ptr [esi+18]    <= Nuestro nombre
:00541AB5 0FB65402FF movzx edx, byte ptr [edx+eax-01]    <= Extrae letra por letra
:00541ABA 03DA add ebx, edx    <= Suma EBX = EBX + EDX (EBX trae 1 en la primera letra)
:00541ABC 48 dec eax
:00541ABD 85C0 test eax, eax
:00541ABF 75F1 jne 00541AB2    <= Si no ha completado el nombre regresa
:00541AC1 8D45F8 lea eax, dword ptr [ebp-08]    <= Vemos que EBX = 648d
:00541AC4 50 push eax
:00541AC5 8B4608 mov eax, dword ptr [esi+08]
:00541AC8 8945D0 mov dword ptr [ebp-30], eax
:00541ACB C645D40B mov [ebp-2C], 0B
:00541ACF 8B460C mov eax, dword ptr [esi+0C]
:00541AD2 8945D8 mov dword ptr [ebp-28], eax
:00541AD5 C645DC0B mov [ebp-24], 0B
:00541AD9 8BC6 mov eax, esi
:00541ADB E85CFFFFFF call 00541A3C
:00541AE0 8845E0 mov byte ptr [ebp-20], al
:00541AE3 C645E402 mov [ebp-1C], 02
:00541AE7 8B4614 mov eax, dword ptr [esi+14]
:00541AEA 8945E8 mov dword ptr [ebp-18], eax
:00541AED C645EC0B mov [ebp-14], 0B
:00541AF1 895DF0 mov dword ptr [ebp-10], ebx
:00541AF4 C645F400 mov [ebp-0C], 00
:00541AF8 8D55D0 lea edx, dword ptr [ebp-30]
:00541AFB B904000000 mov ecx, 00000004
:00541B00 B8641B5400 mov eax, 00541B64
:00541B05 E8D28FECFF call 0040AADC
:00541B0A BB01000000 mov ebx, 00000001    <= EBX recibe 1
:00541B0F 8B45F8 mov eax, dword ptr [ebp-08]    <= Vemos la concatenación 197704241977648
:00541B12 E83D26ECFF call 00404154    <= Cuenta la concatenación
:00541B17 83F801 cmp eax, 00000001    <= Compara con 1
:00541B1A 7C0F jl 00541B2B    <= Si es vacio sale
:00541B1C 8B55F8 mov edx, dword ptr [ebp-08]    <= La concatenación
:00541B1F 0FB65402FF movzx edx, byte ptr [edx+eax-01]    <= Extrae caracter por caracter
:00541B24 03DA add ebx, edx    <= Suma EBX = EBX + EDX (EBX trae 1 la primera vez)
:00541B26 48 dec eax
:00541B27 85C0 test eax, eax
:00541B29 75F1 jne 00541B1C    <= Hasta terminar, recibiremos 797d
:00541B2B 8B55FC mov edx, dword ptr [ebp-04]    <= EDX = 5698d
:00541B2E 0FB74604 movzx eax, word ptr [esi+04]    <= EAX = 5698d o 1642h
:00541B32 03C3 add eax, ebx    <= Suma EBX + EAX (5698+795=6495)
:00541B34 E87780ECFF call 00409BB0
:00541B39 33C0 xor eax, eax
:00541B3B 5A pop edx
:00541B3C 59 pop ecx
:00541B3D 59 pop ecx
:00541B3E 648910 mov dword ptr fs:[eax], edx
:00541B41 68561B5400 push 00541B56
:00541B46 8D45F8 lea eax, dword ptr [ebp-08]
:00541B49 E88623ECFF call 00403ED4
:00541B4E C3 ret

Salimos de la rutina y volvemos a...

:00541BF2 8B45C8 mov eax, dword ptr [ebp-38]    <= Recibe el valor 6495
:00541BF5 8945F4 mov dword ptr [ebp-0C], eax
:00541BF8 C645F80B mov [ebp-08], 0B
:00541BFC 8D55CC lea edx, dword ptr [ebp-34]
:00541BFF B905000000 mov ecx, 00000005
:00541C04 B83C1C5400 mov eax, 00541C3C
:00541C09 E8CE8EECFF call 0040AADC    <= Concatena los valores 1977042419776486495
:00541C0E 33C0 xor eax, eax
:00541C10 5A pop edx
:00541C11 59 pop ecx
:00541C12 59 pop ecx
:00541C13 648910 mov dword ptr fs:[eax], edx
:00541C16 682B1C5400 push 00541C2B
:00541C1B 8D45C8 lea eax, dword ptr [ebp-38]
:00541C1E E8B122ECFF call 00403ED4
:00541C23 C3 ret

Ahora que ya tenemos nuestro serial salimos de TRW2000 y vamos a iniciar el programa normalmente, nos aparece la nagscreen y damos clic en registrar escribimos nuestro nombre y serial y clic en continuar, PRESTO!, ha pasado sin dar el mensaje de chicomalo, reiniciemos el programa tan solo para cerciorarnos.

Vaya! Vaya! Lo que me temía, hay algo que no anda bien, hemos recibido el siguiente mensajito...

¡Código y nombre de usuario no autorizados! blah, blah, blah, etc.

Hasta dice que soy un caradura... ;o)

Qué especie de carajo tiene este programa, vamos a investigar en las Reference Strings...

No encontramos nada, tan solo lo mismo, que ya hemos visto, que podemos hacer, vamos a rastraer desde el principio, pero para eso utilizaremos OllyDBG.

Cargamos el Olly y cargamos el programa en el Olly, vamos al punto de entrada y empezamos a tracear con F8, vemos que extrae nuestros datos del registro de Windows,

HKCU\Sofware\Sarovi\WebScope
Usuario
Registro

Desde la dirección 0058FEC8 nuestro nombre que viene en minúsculas va a ser comparado con otros nombres prohibidos como

asrael, agustin mollo, marcos oliver hengstebek y m4nson

y el código nuestro con los códigos

11111111111119716448,     XXXXXX31003412796624
XXXXXX31005924266626,     XXXX786123454806591
(Las X's es la palabra clave)

Me imagino que cada uno corresponde a los nombres de arriba, pero continuamos y en 0058FF98 se extrae los primeros 6 caracteres de nuestro código 199704 y encontramos un nuevo conjunto de caracteres, con los que se comparan los nuestros en 0058FFAD, como no son iguales nos da el mensaje de ChicoMalo.

Bueno cargamos el regedit y buscamos en él y vamos a cambiar 197704 por el conjunto de caracteres buenos.

Tambien recordemos que en 00541B1C se realizó un calculo para nuestro serial fuera aceptado por el programa, debemos de calcularlo de nuevo, pues hemos cambiado los primeros seis caracteres, sino siempre recibiremos el mensaje de error

RECAPITULANDO

1. Palabra clave (6 Caracteres)
2. Serial de catorce caracteres (no se que pasa si tiene 13)
3. Calcular para el nombre (Decimal de Letra por letra) + 1
4. Unir los primeros 12 caracteres + el calculo del punto 3
5. Calcular para el serial (Decimal de cada caracter por caracter) + 1
6. Unir el punto 4 con el punto 5 para el serial correcto

Al final debe ser así     XXXXXX??????AAAANNNN    <= El tamaño puede variar (19 o 20)

XXXXXX = Palabra Clave
?????? = Cualquier número entre 100000 y 699999
AAAA = Primer resultado
NNNN = Segundo resultado

LA RUTINA DE GENERACION DEL SERIAL

Private Sub Genera()
   MyCode = "PalabraClave"
   For I = 1 To 6
         A = GetRandomNumber(1, 6)
         B = B + Trim(Str(A))
   Next
   MyCode = MyCode + B
   For I = 1 To Len(Trim(Text1.Text))
         EAX = Asc(Mid(Text1.Text, I, 1))
         EBX = EBX + EAX
   Next
   ECX = MyCode + Trim(Str(EBX + 1))
   EBX = 1
   For I = 1 To Len(Trim(ECX))
         EAX = Asc(Mid(ECX, I, 1))
         EBX = EBX + EAX
   Next
   Text2.Text = ECX + Trim(Str(EBX + 5698))
End Sub

Public Function GetRandomNumber(Lower As Integer, Upper As Integer) As Integer
    Randomize
    GetRandomNumber = Int((Upper - Lower + 1) * Rnd + Lower)
End Function




"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, si ha USTED, le gusta el producto por favor COMPRELO, algunas veces... los autores merecen su dinero ;o)"

Saludos a mis buenos amigos Karpoff, Pr@fesor_X, CaoS ReptantE y a todos los crackers hispanohablantes, en especial a ti por que has llegado hasta aquí.

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

ByTESCRK

Nota: Sería bueno que me dijeras en qué momento salí del programa con mensaje de error.  

 

 

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