Autor
Cuando hablamos de cracking de aplicaciones, siempre se piensa que solo aquellas que se encuentran en la red, para disposición del publico general son las que deben poseer diferentes y variados métodos de ofuscamiento para evitar que estas sean crackeadas y puedan utilizarse sin realizar el pago correspondiente de derechos, sin embargo no es así. En esta ocasión mostrare como crackear el PowerPath de EMC. Quien conozca un poco de storage sabrá de lo que hablamos, para los que no, PowerPath es una importante herramienta que sirve para realizar el balanceo de cargas entre diferentes paths que comunican los equipos de emc (Clariion, Symetrix, Celerra etc.), su operación licenciada es de vital importancia para mantener la alta disponibilidad de los LUN’s o discos asignados.
La version que utilizaremos de PowerPath es la siguiente: EMC powermt for PowerPath iSCSI (c) Version :1.1.0 (build 89):
Para realizar el debugging de usaremos el clásico OllyDbg, para revisar si el programa se encuentra empaquetado utilizaremos el también muy común PEiD. Aunque bueno este paso solo se realizó por mero protocolo, pues cuando un programa se encuentra empaquetado las instrucciones son ilegibles. El programa PowerPath posee varias partes las cuales funcionan bajo diferentes escenarios, el licenciamiento nos lo facilitan de manera significativa, pues la gente de emc tuvo la gran idea de poner una aplicación independiente únicamente para este fin. La aplicación se encuentra en la siguiente ruta:
C:\Archivos de programa\EMC\PowerPathiSCSI\EmcLicTool.exe
Por lo tanto esta es la aplicación que verificaremos, no se encuentre empaquetada u ofuscada con el fin de entorpecer nuestro trabajo.
La salida del PEiD nos muestra que la aplicación no se encuentra empaquetada de ninguna manera, incluso nos muestra que fue realizado en C++, con esto estamos listos para cargar el programa en OllyDBG. Pero antes realizaremos algunos ajustes al OllyDbg para evitar problemas durante el debugging.
Para que el OllyDbg no pare en cada intento de entrada a un modulo nuevo, vamos al menú principal y en “Options_Debuggin Options” seleccionamos “Debug” y marcamos “Ignore memory access violations in Kernel 32″ y desmarcamos el resto. Posteriormente nos aseguramos de que no se detecta nuestro debugger con el IsDebuggerPresent, para lo cual se utilizará el Plugin de OllyDbg “IsDebuggerPresent” de Byte Patcher.
De esta manera no encontramos listos para realizar el debugging del programa. Luego de cargar y correr el programa obtenemos la siguiente salida:
La primera salida que nos marca el inicio de la aplicación:
Código:
0040B9A6 >/$ 55 PUSH EBP
0040B9A7 |. 8BEC MOV EBP,ESP
0040B9A9 |. 6A FF PUSH -1
0040B9AB |. 68 689C4200 PUSH EmcLicTo.00429C68
0040B9B0 |. 68 C4F54000 PUSH EmcLicTo.0040F5C4 ; SE handler installation
0040B9B5 |. 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]
0040B9BB |. 50 PUSH EAX
0040B9BC |. 64:8925 000000>MOV DWORD PTR FS:[0],ESP
0040B9C3 |. 83EC 58 SUB ESP,58
0040B9C6 |. 53 PUSH EBX
0040B9C7 |. 56 PUSH ESI
0040B9C8 |. 57 PUSH EDI
0040B9C9 |. 8965 E8 MOV DWORD PTR SS:[EBP-18],ESP
0040B9CC |. FF15 1C724200 CALL DWORD PTR DS:[<&KERNEL32.GetVersion>; kernel32.GetVersion
El PUSH EBP nos indica de donde inicia el programa, ahora usaremos el método mas común para encontrar la sentencia "IF" o CMP de validación, cuando introducimos un código erróneo, introducimos cualquier texto y verificamos el error que arroje:
Posteriormente buscamos la cadena "Key" para ubicar en el desensamblador la linea que nos llevara a este fragmento de código:
Text strings referenced in EmcLicTo:.text, item 5
Address=00401C31
Disassembly=PUSH EmcLicTo.00431344
Text string=ASCII "%s is an invalid license key."
La seguimos en el desensamblador y observaremos lo siguiente:
Código:
00401BED . 53 PUSH EBX
00401BEE . 56 PUSH ESI
00401BEF . 57 PUSH EDI
00401BF0 . 8BF1 MOV ESI,ECX
00401BF2 . 8945 F0 MOV DWORD PTR SS:[EBP-10],EAX
00401BF5 . 33DB XOR EBX,EBX
00401BF7 . 6A 01 PUSH 1
00401BF9 . 895D FC MOV DWORD PTR SS:[EBP-4],EBX
00401BFC . E8 D9BD0100 CALL EmcLicTo.0041D9DA
00401C01 . 8B4E 5C MOV ECX,DWORD PTR DS:[ESI+5C]
00401C04 . E8 C9F9FFFF CALL EmcLicTo.004015D2
00401C09 . 8DBE 5C010000 LEA EDI,DWORD PTR DS:[ESI+15C]
00401C0F . 8945 EC MOV DWORD PTR SS:[EBP-14],EAX
00401C12 . 8B07 MOV EAX,DWORD PTR DS:[EDI]
00401C14 . 3958 F8 CMP DWORD PTR DS:[EAX-8],EBX
00401C17 . 0F84 B9000000 JE EmcLicTo.00401CD6
00401C1D . 8B4E 5C MOV ECX,DWORD PTR DS:[ESI+5C]
00401C20 . 50 PUSH EAX
00401C21 . E8 B8F4FFFF CALL EmcLicTo.004010DE
00401C26 . 3BC3 CMP EAX,EBX
00401C28 . 74 57 JE SHORT EmcLicTo.00401C81
00401C2A . 83F8 50 CMP EAX,50
00401C2D 74 09 JE SHORT EmcLicTo.00401C38
00401C2F . FF37 PUSH DWORD PTR DS:[EDI]
00401C31 . 68 44134300 PUSH EmcLicTo.00431344 ; ASCII "%s is an invalid license key."
00401C36 . EB 26 JMP SHORT EmcLicTo.00401C5E
00401C38 > FF75 EC PUSH DWORD PTR SS:[EBP-14]
00401C3B . 8BCF MOV ECX,EDI
00401C3D . FF75 EC PUSH DWORD PTR SS:[EBP-14]
00401C40 . E8 EB920100 CALL EmcLicTo.0041AF30
00401C45 . 8B4E 5C MOV ECX,DWORD PTR DS:[ESI+5C]
00401C48 . 50 PUSH EAX
00401C49 . E8 F8F8FFFF CALL EmcLicTo.00401546
00401C4E . 6A FF PUSH -1
00401C50 . 8BCF MOV ECX,EDI
00401C52 . E8 B1920100 CALL EmcLicTo.0041AF08
00401C57 . FF37 PUSH DWORD PTR DS:[EDI]
00401C59 . 68 24134300 PUSH EmcLicTo.00431324 ; ASCII "%s has already been entered."
Para poder seguir la traza del programa pondremos un breakpoint en 00401BED . 53 PUSH EBX (F2) y seguiremos la traza paso a paso con F7.
Una vez que se realiza la corrida paso por paso nos podemos dar cuenta que la llamada CALL EmcLicTo.0041D9DA ubicada en la dirección 00401BFC efectivamente es la que realiza la validación inicial de cada uno de los caracteres que se van introduciendo, si analizamos la corrida del siguiente fragmento de código encontraremos lo siguiente: (siguiendo la llamada)
Código:
0041D9DA $ B8 78654200 MOV EAX,EmcLicTo.00426578
0041D9DF . E8 64DCFEFF CALL EmcLicTo.0040B648
0041D9E4 . 83EC 24 SUB ESP,24
0041D9E7 . 53 PUSH EBX
0041D9E8 . 56 PUSH ESI
0041D9E9 . 57 PUSH EDI
0041D9EA . 8BF1 MOV ESI,ECX
0041D9EC . 8965 F0 MOV DWORD PTR SS:[EBP-10],ESP
0041D9EF . FF75 08 PUSH DWORD PTR SS:[EBP+8]
0041D9F2 . 8D4D D4 LEA ECX,DWORD PTR SS:[EBP-2C]
0041D9F5 . 56 PUSH ESI
0041D9F6 . E8 81000000 CALL EmcLicTo.0041DA7C
0041D9FB . E8 104F0000 CALL EmcLicTo.00422910
0041DA00 . 8BF8 MOV EDI,EAX
0041DA02 . 8365 08 00 AND DWORD PTR SS:[EBP+8],0
0041DA06 . 8365 FC 00 AND DWORD PTR SS:[EBP-4],0
0041DA0A . 897D EC MOV DWORD PTR SS:[EBP-14],EDI
0041DA0D . 8B8F B8000000 MOV ECX,DWORD PTR DS:[EDI+B8]
0041DA13 . 8D87 B8000000 LEA EAX,DWORD PTR DS:[EDI+B8]
0041DA19 . 894D E8 MOV DWORD PTR SS:[EBP-18],ECX
0041DA1C . 8B4E 1C MOV ECX,DWORD PTR DS:[ESI+1C]
0041DA1F . 8908 MOV DWORD PTR DS:[EAX],ECX
0041DA21 . 8B06 MOV EAX,DWORD PTR DS:[ESI]
0041DA23 . 8D4D D4 LEA ECX,DWORD PTR SS:[EBP-2C]
0041DA26 . 51 PUSH ECX
0041DA27 . 8BCE MOV ECX,ESI
0041DA29 . FF90 84000000 CALL DWORD PTR DS:[EAX+84]
0041DA2F . C745 08 010000>MOV DWORD PTR SS:[EBP+8],1
0041DA36 . EB 27 JMP SHORT EmcLicTo.0041DA5F
0041DA38 . B8 5CDA4100 MOV EAX,EmcLicTo.0041DA5C
0041DA3D . C3 RETN
Lo que hace es obtener el tope de ESP y concatena la entrada del input text en la parte baja y alta del acumulador:
Código:
0041DA02 . 8365 08 00 AND DWORD PTR SS:[EBP+8],0
0041DA06 . 8365 FC 00 AND DWORD PTR SS:[EBP-4],0
0041DA0A . 897D EC MOV DWORD PTR SS:[EBP-14],EDI
0041DA0D . 8B8F B8000000 MOV ECX,DWORD PTR DS:[EDI+B8]
0041DA13 . 8D87 B8000000 LEA EAX,DWORD PTR DS:[EDI+B8]
Posteriormente realiza una llamada mas que es precisamente la que necesitaríamos debuggear si quisiéramos hacer el keygen para PowerPath ( CALL EmcLicTo.0041DA7C y CALL EmcLicTo.00422910 ), prepara el resto de los registros con la información necesaria para regresar a su salto de origen guardando las direcciones de salto y regreso en ECX… sin embargo esa no es la prioridad, por lo tanto pasaremos a un breakpoint mas cercano al CMP definitivo. El nuevo Breakpoint lo fijaremos en: PUSH DWORD PTR DS:[EDI] ubicado en la dirección 00401C2F, justo una instrucción antes de emitir el mensaje de error, ahora bien, una instrucción arriba se encuentra el salto de validación definitivo entre lo que se devuelve de la llamada 00422910 acumulado en el ECX, si ECX es igual que el valor sostenido en el tope de nuestro stack (dump) entonces realiza un salto a la dirección de memoria: 00401C38 que es la que almacena el còdigo de escritura en los registros de PowerPath, informándole que la licencia fue introducida de manera correcta, de lo contrario no brinca y arroja el mensaje de Licencia Errónea (is an invalid licence key) y realiza un salto corto a la dirección JMP SHORT EmcLicTo.00401C5E indicándole a PowerPath no reescribir registros y dejar el programa en espera de nuevas entradas:
Código:
00401C26 . 3BC3 CMP EAX,EBX
00401C28 . 74 57 JE SHORT EmcLicTo.00401C81
00401C2A . 83F8 50 CMP EAX,50
00401C2D 74 09 JE SHORT EmcLicTo.00401C38
00401C2F . FF37 PUSH DWORD PTR DS:[EDI]
00401C31 . 68 44134300 PUSH EmcLicTo.00431344 ; ASCII "%s is an invalid license key."
00401C36 . EB 26 JMP SHORT EmcLicTo.00401C5E
00401C38 > FF75 EC PUSH DWORD PTR SS:[EBP-14]
00401C3B . 8BCF MOV ECX,EDI
00401C3D . FF75 EC PUSH DWORD PTR SS:[EBP-14]
00401C40 . E8 EB920100 CALL EmcLicTo.0041AF30
00401C45 . 8B4E 5C MOV ECX,DWORD PTR DS:[ESI+5C]
00401C48 . 50 PUSH EAX
00401C49 . E8 F8F8FFFF CALL EmcLicTo.00401546
00401C4E . 6A FF PUSH -1
00401C50 . 8BCF MOV ECX,EDI
00401C52 . E8 B1920100 CALL EmcLicTo.0041AF08
00401C57 . FF37 PUSH DWORD PTR DS:[EDI]
00401C59 . 68 24134300 PUSH EmcLicTo.00431324 ; ASCII "%s has already been entered."
00401C5E > 8D45 F0 LEA EAX,DWORD PTR SS:[EBP-10]
00401C61 . 50 PUSH EAX
00401C62 . E8 F97E0100 CALL EmcLicTo.00419B60
00401C67 . 83C4 0C ADD ESP,0C
PowerPath escribe en el registro del S.O. si la licencia es o no correcta entre otras cuestiones, eso lo podemos verificar por sus scripts poco seguros y a disposición de cualquier persona que se instalan con el software de manera nativa:
Código:
(cabecera de powermt.vbs)
REM MPIO EMC DSM Driver Powermt CLI
On Error Resume Next
Function GetDateTime()
MyTime = Now
GetDateTime = Mytime
End Function ‘GetDateTime()
Function Test()
On Error Resume Next
set configEnum = GetObject(“winmgmts:root\wmi:EMCMPIODSM_CONFIGINFO”).Instances_
If Err <> 0 Then
WScript.Echo “Device Not found”
WScript.Quit
End If
End Function
En este script queda evidenciado la utilización de DLL’s que los desarrolladores anexan a la API de Windows y de manera análoga acceden a registros de Windows que validan licencias. Por lo tanto solo basta obligar al programa de licenciamiento a que brinque esta validación para obligarlo a que escriba en el registro que nuestra licencia completamente fake es correcta. Para lograr esto cambiaremos la instrucción JE SHORT EmcLicTo.00401C38 ubicada en la dirección 00401C2D por JNZ SHORT 00401C38, la instrucción JNZ es lo contrario de JE, es decir evaluará si es diferente de 0 o de lo almacenado en el acumulador; ensamblamos y observamos que ocurre:
Ahora nos muestra la pantalla diciéndonos que la licencia fue introducida de manera correcta, y debido a que PowerPath posee poca granularidad en cuanto a la seguridad a nivel de código se refiere, nuestro sistema se encuentra licenciado al menos hasta la próxima que se reinicie el equipo:
Esta versión de PowerPath desarrollada por EMC es mas fácil de crackear que mucho del software que se encuentra en la red, el cual posee métodos de ofuscamiento para dificultar el cracking de la aplicación en cuestión y en general sirve para incrementar la experiencia en el cracking de aplicaciones. Si algún SySAdmin con mínimo valor de la pluralidad estructural del software libre conociera esto dejarian de consumir miles de dolares en licencias para software realizado sín las mínimas consideraciones de seguridad.
Artículo completo en: http://jesusssx.wordpress.com/2010/03/02/cracking-powerpath-emc
Saludos !!
En línea
