Solución para el KeygenMe ASM de Flamer

por ·4 comentarios

Intro

El crackme que analizamos hoy está hecho en ensamblador y si bien su dificultad es baja, la creación del keygen es un poco liosa. Al keygen que veremos más adelante, le he dado cierta aleatoriedad para que quede más elegante.

El crackme comprueba el serial en función de un identificador de 4 dígitos que el mismo crackme genera.

Análisis

Coje nuestro serial mediante la función GetDlgItemTextA.

004010D3  |.  68 FF000000   PUSH 0FF                                 ; /MaxCount = 255.
004010D8  |.  68 40324000   PUSH OFFSET 00403240                     ; |String
004010DD  |.  68 EC030000   PUSH 3EC                                 ; |ItemID = 1004.
004010E2  |.  FF75 08       PUSH DWORD PTR SS:[ARG.1]                ; |hDialog => [ARG.1]
004010E5  |.  E8 6E010000   CALL <JMP.&user32.GetDlgItemTextA>       ; \USER32.GetDlgItemTextA
004010EA  |.  68 40324000   PUSH OFFSET 00403240                     ; /String
004010EF  |.  E8 52010000   CALL <JMP.&kernel32.lstrlenA>            ; \KERNEL32.lstrlen
004010F4  |.  A3 47334000   MOV DWORD PTR DS:[403347],EAX
004010F9  |.  33DB          XOR EBX,EBX
004010FB  |.  33C0          XOR EAX,EAX
004010FD  |.  EB 54         JMP SHORT 00401153

Comprueba que nuestro serial esté formado por números (30h – 39h), letras de la A a la F (41h – 46h) y el guión (2Dh), es decir, el alfabeto hexadecimal más el guión. Si hay algún dígito indeseado nos tira fuera.

004010FF  |>  8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240]
00401105  |.  3C 2D         |CMP AL,2D
00401107  |.  74 40         |JE SHORT 00401149
00401109  |.  3C 30         |CMP AL,30
0040110B  |.  74 3C         |JE SHORT 00401149
0040110D  |.  3C 31         |CMP AL,31
0040110F  |.  74 38         |JE SHORT 00401149
00401111  |.  3C 32         |CMP AL,32
00401113  |.  74 34         |JE SHORT 00401149
00401115  |.  3C 33         |CMP AL,33
00401117  |.  74 30         |JE SHORT 00401149
00401119  |.  3C 34         |CMP AL,34
0040111B  |.  74 2C         |JE SHORT 00401149
0040111D  |.  3C 35         |CMP AL,35
0040111F  |.  74 28         |JE SHORT 00401149
00401121  |.  3C 36         |CMP AL,36
00401123  |.  74 24         |JE SHORT 00401149
00401125  |.  3C 37         |CMP AL,37
00401127  |.  74 20         |JE SHORT 00401149
00401129  |.  3C 38         |CMP AL,38
0040112B  |.  74 1C         |JE SHORT 00401149
0040112D  |.  3C 39         |CMP AL,39
0040112F  |.  74 18         |JE SHORT 00401149
00401131  |.  3C 41         |CMP AL,41
00401133  |.  74 14         |JE SHORT 00401149
00401135  |.  3C 42         |CMP AL,42
00401137  |.  74 10         |JE SHORT 00401149
00401139  |.  3C 43         |CMP AL,43
0040113B  |.  74 0C         |JE SHORT 00401149
0040113D  |.  3C 44         |CMP AL,44
0040113F  |.  74 08         |JE SHORT 00401149
00401141  |.  3C 45         |CMP AL,45
00401143  |.  74 04         |JE SHORT 00401149
00401145  |.  3C 46         |CMP AL,46
00401147  |.  75 07         |JNE SHORT 00401150
00401149  |>  8305 4B334000 |ADD DWORD PTR DS:[40334B],1
00401150  |>  83C3 01       |ADD EBX,1
00401153  |>  3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347]
00401159  |.^ 76 A4         \JBE SHORT 004010FF
0040115B  |. A1 47334000 MOV EAX,DWORD PTR DS:[403347]
00401160  |. 3905 4B334000 CMP DWORD PTR DS:[40334B],EAX     ; si no coincide el tamaño del serial con el
00401166  |. 0F85 94000000 JNE 00401200                      ; contador nos tira fuera

La comprobación del serial la realiza sumando el valor ascii del primer dígito al valor ascii del tercero y sucesivos y a continuación restando la suma anterior al ID. Cuando finalice la comprobación de todos los dígitos del serial, el restador tiene que ser cero, de lo contrario nos tira fuera. Si el ID es cero también nos tira fuera.

Ejemplo (base 10)para ID = 4011 y SERIAL: 1-23456

  • Valores del serial: 1(49) -(no se usa) 2(50) 3(51) 4(52) 5(53) 6(54)
  • 1º + 3º: 49 + 50 = 99
  • 4011 – 99 = 3912
  • 1º + 4º: 49 + 51 = 100
  • 3912 – 100 = 3812
  • 1º + 5º: 49 + 52 = 101
  • 3812 – 101 = 3711
  • 1º + 6º: 49 + 53 = 102
  • 3711 – 102 = 3609
  • 1º + 7º: 49 + 54 = 103
  • 3609 – 103 = 3506
  • ¿3506 = 0?
0040116C  |.  33C0          XOR EAX,EAX
0040116E  |.  BB 02000000   MOV EBX,2
00401173  |.  A0 40324000   MOV AL,BYTE PTR DS:[403240]
00401178  |.  A3 43334000   MOV DWORD PTR DS:[403343],EAX
0040117D  |.  EB 13         JMP SHORT 00401192
0040117F  |>  8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240]         ; Coje el dígito correspondiente
00401185  |.  0305 43334000 |ADD EAX,DWORD PTR DS:[403343]           ; 1ºdig + dig
0040118B  |.  2905 4F334000 |SUB DWORD PTR DS:[40334F],EAX           ; ID - (1ºdig + dig)
00401191  |.  43            |INC EBX
00401192  |>  3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347]
00401198  |.^ 72 E5         \JB SHORT 0040117F
0040119A  |.  833D 4F334000 CMP DWORD PTR DS:[40334F],0              ; CHECK RESTADOR SEA = 0
004011A1  |.  75 49         JNE SHORT 004011EC
004011A3  |.  833D 3F334000 CMP DWORD PTR DS:[40333F],0              ; CHECK ID <> 0
004011AA  |.  74 40         JE SHORT 004011EC
004011AC  |.  FF35 3F334000 PUSH DWORD PTR DS:[40333F]               ; /<%d> = 0
004011B2  |.  68 00304000   PUSH OFFSET 00403000                     ; |Format = "REGISTRADO CON ID:%d"
004011B7  |.  68 40324000   PUSH OFFSET 00403240                     ; |Buf
004011BC  |.  E8 A9000000   CALL <JMP.&user32.wsprintfA>             ; \USER32.wsprintfA

Como veis, el resultado de ir restando todos los dígitos de nuestro serial con la ID debe ser cero para que el serial sea correcto.

Keygen

Lo primero que se me ocurre para obtener una solución directa es buscar una combinación de dígito + dígito que sea múltiplo del ID. Para ello podemos usar la función módulo. La función módulo lo que hace es darnos el resto de la división de dos números, de modo que si el resto es cero los números son múltiplos. Para ello debemos cruzar todos los números y letras hasta encontrar los dígitos múltiplos del ID. Un serial de este primer tipo quedaría algo así como 1-FFFFFFFFFFFFFFFFFF ya que como el primer dígito es fijo el otro se repetirá tanta veces como sea necesario para hacer que el ID sea cero.

Con nuestro reducido alfabeto, cabe la posibilidad de que no encontremos una combinación válida, por lo que tendremos que pensar en un plan B. El plan B que se me ocurre a mi es intentar forzar el plan A restando caracteres aleatorios al ID y volviendo a comprobar si encontramos múltiplos del nuevo ID. Un serial de este tipo quedaría más elegante, por ejemplo 3-A6D53B628BBBBB.

Os dejo unos cuantos números de serie.

  • Tipo A
    • ID: 1111 SERIAL: 0-55555555555
    • ID: 2500 SERIAL: 0-4444444444444444444444444
    • ID: 4982 SERIAL: 1-99999999999999999999999999999999999999999999999
    • ID: 4992 SERIAL: 0-0000000000000000000000000000000000000000000000000000
  • Tipo B
    • ID: 1112 SERIAL: 9-19247C5555
    • ID: 2499 SERIAL: A-C5ADC2233333333333333
    • ID: 4981 SERIAL: 7-C6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
    • ID: 4999 SERIAL: 4-A37BEEB8146A5CE6ECFB422B1BFF8474E852314F5A999
'Keygen for Flamer's asm keygenme
    Dim id As Integer
    Dim serial As String
    Dim tmp, tmp2, na, nb As Integer
    Dim alfabeto As Integer() = New Integer() {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70}
    Dim r As Random = New Random
    'Button generate
    Private Sub btngen_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btngen.Click
ini:
        If txtid.TextLength <> 4 Then GoTo Mal
        id = txtid.Text
        txtdebug.Text = ""
        na = alfabeto(r.Next(1, 16))
        serial = Chr(na) & "-"
        tmp = id
        For i = 0 To alfabeto.Length - 1
            For y = 0 To alfabeto.Length - 1
                'Solución directa
                If id Mod (alfabeto(i) + alfabeto(y)) = 0 Then
                    tmp = id / (alfabeto(i) + alfabeto(y))
                    txtserial.Text = Chr(alfabeto(i)) & "-"
                    For z = 0 To tmp - 1
                        txtserial.Text &= Chr(alfabeto(y))
                    Next
                    GoTo fuera
                End If
                'Indirecta con aleatoriedad
                nb = alfabeto(r.Next(1, 16))
                tmp = tmp - (na + nb)
                serial &= Chr(nb)
                If tmp Mod (na + nb) = 0 Then
                    tmp2 = tmp / (na + nb)
                    For z = 0 To tmp2 - 1
                        serial &= Chr(nb)
                    Next
                    txtserial.Text = serial
                    GoTo fuera
                End If
                If tmp < 0 Then
                    GoTo ini
                Else
                    txtdebug.Text &= tmp & " "
                End If
            Next
        Next
Mal:
        txtserial.Text = "¿id?"
fuera:

    End Sub

Me doy cuenta que en el keygen no he utilizado el guión, pero no pasa nada, se lo dejo al lector como curiosidad.

Links

Keygen para el CrackMe Pythagoras de Spider
Introducción Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por
lost_in_bin
Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la
ThisIsLegal.com - Realistic Challenge 1
Warning: This challenge is still active and therefore should not be resolved using this information.  Aviso: Este reto sigue en
Stego X - Chunk
Intro Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir

Keygen para el CrackMe Pythagoras de Spider

por ·Sin comentarios

Introducción

Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por eso, vamos a tener que lidiar con ciertas peculiaridades al realizar el keygen con un lenguaje de bajo nivel.

Al inicio comprueba la longitud del nombre y de el número de serie. El nombre debe tener al menos 6 caracteres y el número de serie debe tener 10. Os adelanto ya que la asignación de memoria del nombre es de 9 caracteres, es decir, da igual la longitud del nombre que solo va a usar 9.

004014AD | E8 1A 02 00 00           | call <pythagoras.GetWindowTextA>        | ;Lee el nombre
004014B2 | 83 F8 06                 | cmp eax,6                               | ;Nombre >=6 caracteres
004014B5 | 0F 82 03 01 00 00        | jb pythagoras.4015BE                    |
004014BB | 6A 14                    | push 14                                 |
004014BD | 68 D9 31 40 00           | push pythagoras.4031D9                  | ;004031D9:"1234567890"
004014C2 | FF 35 10 32 40 00        | push dword ptr ds:[403210]              |
004014C8 | E8 FF 01 00 00           | call <pythagoras.GetWindowTextA>        | ;Lee el serial
004014CD | 83 F8 0A                 | cmp eax,A                               | ;Serial debe tener 10 (A) caracteres
004014D0 | 0F 85 E8 00 00 00        | jne pythagoras.4015BE                   |

Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890

A continuación chequea que nuestro serial tenga caracteres hexadecimales.

004014DA | 8A 81 D9 31 40 00        | mov al,byte ptr ds:[ecx+4031D9]         | ; ecx+004031D9:"1234567890"
004014E0 | 3C 00                    | cmp al,0                                | ; contador del bucle
004014E2 | 74 1F                    | je pythagoras.401503                    | ; fin del bucle
004014E4 | 3C 30                    | cmp al,30                               | ; 0x30 = número 1
004014E6 | 0F 82 D2 00 00 00        | jb pythagoras.4015BE                    | ; < 30 bad boy
004014EC | 3C 46                    | cmp al,46                               | ; 0x46 = letra F
004014EE | 0F 87 CA 00 00 00        | ja pythagoras.4015BE                    | ; > 46 bad boy
004014F4 | 3C 39                    | cmp al,39                               | ; 0x39 = número 9
004014F6 | 76 08                    | jbe pythagoras.401500                   | ; <=39 ok continua el bucle
004014F8 | 3C 41                    | cmp al,41                               | ; 0x41 = letra A
004014FA | 0F 82 BE 00 00 00        | jb pythagoras.4015BE                    | ; <41 bad boy
00401500 | 41                       | inc ecx                                 | ; contador += 1
00401501 | EB D7                    | jmp pythagoras.4014DA                   | ; bucle

Continua realizando un sumatorio con nuestro nombre, pero tenemos que tener especial cuidado al tratamiento de los datos, ya que el crackme al estar hecho en ensamblador puede jugar con los registros como quiere y eso nos puede inducir a error.

0040150B | 3C 00                    | cmp al,0                                | ; ¿Fin bucle?
0040150D | 74 05                    | je pythagoras.401514                    | ; Salta fuera del bucle si procede
0040150F | 02 D8                    | add bl,al                               | ; bl = bl + al
00401511 | 41                       | inc ecx                                 | ; contador +=1
00401512 | EB F1                    | jmp pythagoras.401505                   | ; bucle

Si os fijáis utiliza registros de 8 bits como son AL y BL. Debajo os dejo una explicación de EAX pero para EBX es lo mismo.

               EAX
-----------------------------------
                         AX
                  -----------------
                     AH       AL
                  -------- --------
00000000 00000000 00000000 00000000
 (8bit)   (8bit)   (8bit)   (8bit)
 

  EAX     (32 bit)
--------
     AX   (16 bit)
    ----
    AHAL  (AH y AL 8 bit)
--------
00000000

El uso de registros de 8 bits nos implica tomar precauciones al realizar el Keygen debido a que por ejemplo, en .Net no tenemos la capacidad de decirle que haga una suma y que nos devuelva solamente 8 bits del resultado. Veamos como ejemplo para el nombre «deurus». La suma de los caracteres hexadecimales quedaría:

64+65+75+72+75+73 = 298, es decir, EAX = 00000298

Pero recordad que el crackme solo cogerá el 98 que es lo correspondiente al registro AL. De momento nos quedamos con nuestro SUMNOMBRE = 98.

Primera condición

A continuación coge los dos primeros caracteres del serial y les resta nuestro SUMNOMBRE y comprueba que el resultado esté entre 4 (0x4) y -4 (0xFC).

0040154B | 0F B6 05 F3 31 40 00     | movzx eax,byte ptr ds:[4031F3]          |
00401552 | 8A C8                    | mov cl,al                               |
00401554 | 2A CB                    | sub cl,bl                               | ; CL = CL - BL | CL = 12 - 98 = 7A
00401556 | 80 F9 04                 | cmp cl,4                                | ; Compara CL con 4
00401559 | 7F 63                    | jg pythagoras.4015BE                    | ; Salta si es mayor
0040155B | 80 F9 FC                 | cmp cl,FC                               | ; Compara CL con FC (-4)
0040155E | 7C 5E                    | jl pythagoras.4015BE                    | ; Salta si es menor

Como veis, el resultado de la resta da 7A (122) que al ser mayor que 4 nos echa vilmente. Aquí de nuevo utiliza registros de 8 bits por lo que debemos tener cuidado con las operaciones matemáticas para no cometer errores, veamos un ejemplo para clarificar de aquí en adelante.

Utilizando 8 bits
-----------------
12 - 98 = 7A que en decimal es 122

Utilizando 16 bits
------------------
0012 - 0098 = FF7A que en decimal es -134

Ahora ya veis la diferencia entre FC (252) y FFFC (-4). Estrictamente, el crackme comprueba el rango entre 4 (4) y FC (122) al trabajar con registros de 8 bits pero nosotros, como veremos más adelante tomaremos el rango entre 4 y -4. De momento, para poder continuar depurando cambiamos los dos primeros caracteres del serial de 12 a 98, ya que 98 – 98 = 0 y cumple la condición anterior.

Introducimos Nombre: deurus y Serial: 9834567890

Segunda condición

Analicemos el siguiente código.

00401560 | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
00401562 | 8B D8                    | mov ebx,eax                             | ; EBX = EAX
00401564 | 0F B7 05 F4 31 40 00     | movzx eax,word ptr ds:[4031F4]          | ; EAX = 3456 (4 dígitos siguientes del serial)
0040156B | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
0040156D | 03 D8                    | add ebx,eax                             | ; EBX = EBX + EAX
0040156F | 0F B7 05 F6 31 40 00     | movzx eax,word ptr ds:[4031F6]          | ; EAX = 7890 (4 últimos dígitos del serial)
00401576 | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
00401578 | 33 C3                    | xor eax,ebx                             | ; EAX
0040157A | 75 42                    | jne pythagoras.4015BE                   | ; Salta si el flag ZF no se activa

En resumen:

  • 98 * 98 = 5A40 (98²)
  • 3456 * 3456 = 0AB30CE4 (3456²)
  • 0AB36724 + 5A40 = 0AB36724
  • 7890 * 7890 = 38C75100 (7890²)
  • 38C75100 XOR 0AB36724 = 32743624
  • Si el resultado del XOR no es cero nuestro serial no pasa la comprobación.

Es decir, Pitágoras entra en escena -> 7890² = 98² + 3456²

Serial = aabbbbcccc

Tercera condición

Finalmente comprueba lo siguiente:

0040157C | 66 A1 F6 31 40 00        | mov ax,word ptr ds:[4031F6]             | ; AX = 7890
00401582 | 66 2B 05 F4 31 40 00     | sub ax,word ptr ds:[4031F4]             | ; AX = 7890 - 3456 = 443A
00401589 | 2C 08                    | sub al,8                                | ; AL = 3A - 8 = 32
0040158B | 75 31                    | jne pythagoras.4015BE                   | ; Si el resultado de la resta no ha sido cero, serial no válido
0040158D | 6A 30                    | push 30                                 |
0040158F | 68 B0 31 40 00           | push pythagoras.4031B0                  | ;004031B0:":-) Well done!!!"
00401594 | 68 7F 31 40 00           | push pythagoras.40317F                  | ;0040317F:"Bravo, hai trovato il seriale di questo CrackMe!"
00401599 | FF 75 08                 | push dword ptr ds:[ebp+8]               |

En resumen:

  • 7890 – 3456 – 8 = 0

Creación del Keygen

Nuestro serial tiene que cumplir tres condiciones para ser válido.

  • a – SUMNOMBRE debe estar entre 4 y -4
  • c² = a² + b²
  • c – b – 8 = 0

Como hemos dicho anteriormente, tomaremos el SUMNOMBRE y le sumaremos y restaremos valores siempre y cuando el resultado esté entre 4 y -4. Para deurus hemos dicho que el SUMNOMBRE es 98 por lo que los posibles valores de «a» se pueden ver debajo. Además debemos tener en cuenta que el crackme solo lee los 9 primeros dígitos del nombre.

98-4 = 94		
98-3 = 95		
98-2 = 96		
98-1 = 97		
98-0 = 98		
98+1 = 99		
98+2 = 9A		
98+3 = 9B		
98+4 = 9C

Es evidente que para encontrar el valor de «c» vamos a tener que utilizar fuerza bruta chequeando todos los valores  de «b» comprendidos entre 0 y FFFF (65535). Además, como trabajaremos en un lenguaje de alto nivel, debemos descartar los resultados decimales. Esto nos limitará los seriales válidos asociados a un determinado nombre. Si realizáramos el keygen en ensamblador obtendríamos bastantes más seriales válidos.

Una vez encontrados los valores enteros de la operación «c² = a² + b²», se debe cumplir que «c – b – 8 = 0», lo que nos limitará bastante los resultados.

    Private Sub btn_generar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_generar.Click
        Try
            If txt_nombre.TextLength > 5 Then
                lst_serials.Items.Clear()
                Dim tmp, c, cx As String
                Dim sumanombre, tmp2 As Integer
                If txt_nombre.TextLength > 9 Then tmp2 = 8 Else tmp2 = txt_nombre.TextLength - 1
                'Calculo el SUMNOMBRE
                For i = 0 To tmp2
                    sumanombre += Asc(Mid(txt_nombre.Text, i + 1, 1)) 'Acumulo suma
                    tmp = Strings.Right(Hex(sumanombre).ToString, 2)  'Solo 8 bits (Registro AL)
                    sumanombre = Val("&H" & tmp) 'Paso a decimal
                Next
                tmp = Strings.Right(Hex(sumanombre).ToString, 2)
                sumanombre = CInt("&H" & tmp)
                txtdebug.Text = "- SumNombre = " & Hex(sumanombre) & vbCrLf
                txtdebug.Text &= "----------------------------------------------" & vbCrLf
                Dim a(8) As Integer
                '
                'a - sumanombre >=4 y <=4
                '
                a(0) = sumanombre - 4
                a(1) = sumanombre - 3
                a(2) = sumanombre - 2
                a(3) = sumanombre - 1
                a(4) = sumanombre
                a(5) = sumanombre + 1
                a(6) = sumanombre + 2
                a(7) = sumanombre + 3
                a(8) = sumanombre + 4
                txtdebug.Text &= "- Posibles valores de 'a'" & vbCrLf
                For i = 0 To a.Length - 1
                    txtdebug.Text &= Hex(a(i)) & " "
                Next
                txtdebug.Text &= "----------------------------------------------" & vbCrLf
                txtdebug.Text &= "- Buscando valores de b y c" & vbCrLf
                txtdebug.Text &= "Serial = aabbbbcccc" & vbCrLf
                '
                'c = sqr(a^2 + b^2)
                '
                txtdebug.Text &= "(1) c = raiz(a^2 + b^2)" & vbCrLf
                txtdebug.Text &= "(2) c - b - 8 = 0" & vbCrLf
                For i = 0 To a.Length - 1 ' todas las posibilidades de a
                    For b = 0 To 65535 'b -> 0000 - FFFF
                        c = Math.Sqrt(a(i) ^ 2 + b ^ 2)
                        If c.Contains(".") Then 'busco enteros
                        Else
                            cx = c - b - 8
                            cx = Hex(cx).PadLeft(4, "0"c)
                            lbl_info.Text = cx
                            If cx = "0000" Then
                                txtdebug.Text &= " (1) " & Hex(c).PadLeft(4, "0"c) & " = raiz(" & Hex(a(i)).PadLeft(2, "0"c) & "^2 + " & Hex(b).PadLeft(4, "0"c) & "^2)" & vbCrLf
                                lst_serials.Items.Add(Hex(a(i)).PadLeft(2, "0"c) & Hex(b).PadLeft(4, "0"c) & Hex(c).PadLeft(4, "0"c))
                                txtdebug.Text &= " (2) " & Hex(c).PadLeft(4, "0"c) & " - " & Hex(b).PadLeft(4, "0"c) & " - 8 = 0" & vbCrLf
                            End If
                        End If
                        Application.DoEvents()
                    Next
                Next
                lbl_info.Text = "Búsqueda finalizada"
            End If
        Catch ex As Exception
            MsgBox(ex.ToString)
        End Try

Enlaces

lost_in_bin

por ·Sin comentarios

Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la solución en el decompilado y quizá por evocar recuerdos de tiempos pretéritos.

ELF Decompilado

/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
   Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

__int64 (**init_proc())(void);
__int64 sub_400650(); // weak
// int printf(const char *format, ...);
// int puts(const char *s);
// void __noreturn exit(int status);
// size_t strlen(const char *s);
// __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD); weak
// int sprintf(char *s, const char *format, ...);
// __int64 ptrace(enum __ptrace_request request, ...);
// __int64 strtol(const char *nptr, char **endptr, int base);
// __int64 __isoc99_scanf(const char *, ...); weak
// int memcmp(const void *s1, const void *s2, size_t n);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void *sub_400730();
__int64 sub_400760();
void *sub_4007A0();
__int64 sub_4007D0();
void fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// __int64 _gmon_start__(void); weak

//-------------------------------------------------------------------------
// Data declarations

_UNKNOWN main;
_UNKNOWN init;
__int64 (__fastcall *funcs_400E29)() = &sub_4007D0; // weak
__int64 (__fastcall *off_601DF8)() = &sub_4007A0; // weak
__int64 (*qword_602010)(void) = NULL; // weak
char *off_602080 = "FLAG-%s\n"; // idb
char a7yq2hryrn5yJga[16] = "7Yq2hrYRn5Y`jga"; // weak
const char aO6uH[] = "(O6U,H\""; // idb
_UNKNOWN unk_6020B8; // weak
_UNKNOWN unk_6020C8; // weak
char byte_6020E0; // weak
char s1; // idb
char byte_602110[]; // weak
char byte_602120[33]; // weak
char byte_602141[7]; // idb
__int64 qword_602148; // weak
__int64 qword_602150; // weak
__int64 qword_602158; // weak
__int64 qword_602160; // weak
__int64 qword_602178; // weak


//----- (0000000000400630) ----------------------------------------------------
__int64 (**init_proc())(void)
{
  __int64 (**result)(void); // rax

  result = &_gmon_start__;
  if ( &_gmon_start__ )
    return (__int64 (**)(void))_gmon_start__();
  return result;
}
// 6021D8: using guessed type __int64 _gmon_start__(void);

//----- (0000000000400650) ----------------------------------------------------
__int64 sub_400650()
{
  return qword_602010();
}
// 400650: using guessed type __int64 sub_400650();
// 602010: using guessed type __int64 (*qword_602010)(void);

//----- (0000000000400700) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
  __int64 v3; // rax
  int v4; // esi
  __int64 v5; // [rsp-8h] [rbp-8h] BYREF
  char *retaddr; // [rsp+0h] [rbp+0h] BYREF

  v4 = v5;
  v5 = v3;
  _libc_start_main((int (__fastcall *)(int, char **, char **))main, v4, &retaddr, (void (*)(void))init, fini, a3, &v5);
  __halt();
}
// 400706: positive sp value 8 has been found
// 40070D: variable 'v3' is possibly undefined

//----- (0000000000400730) ----------------------------------------------------
void *sub_400730()
{
  return &unk_6020C8;
}

//----- (0000000000400760) ----------------------------------------------------
__int64 sub_400760()
{
  return 0LL;
}

//----- (00000000004007A0) ----------------------------------------------------
void *sub_4007A0()
{
  void *result; // rax

  if ( !byte_6020E0 )
  {
    result = sub_400730();
    byte_6020E0 = 1;
  }
  return result;
}
// 6020E0: using guessed type char byte_6020E0;

//----- (00000000004007D0) ----------------------------------------------------
__int64 sub_4007D0()
{
  return sub_400760();
}

//----- (00000000004007D7) ----------------------------------------------------
__int64 __fastcall main(int a1, char **a2, char **a3)
{
  size_t v3; // rax
  size_t v4; // rax
  int i; // [rsp+1Ch] [rbp-24h]
  int n; // [rsp+20h] [rbp-20h]
  int m; // [rsp+24h] [rbp-1Ch]
  int k; // [rsp+28h] [rbp-18h]
  int j; // [rsp+2Ch] [rbp-14h]

  if ( ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1 )
    goto LABEL_2;
  if ( a1 > 4 )
  {
    qword_602148 = strtol(a2[1], 0LL, 10);
    if ( qword_602148 )
    {
      qword_602150 = strtol(a2[2], 0LL, 10);
      if ( qword_602150 )
      {
        qword_602158 = strtol(a2[3], 0LL, 10);
        if ( qword_602158 )
        {
          qword_602160 = strtol(a2[4], 0LL, 10);
          if ( qword_602160 )
          {
            if ( -24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
              && 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
              && 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
              && -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613 )
            {
              qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;
              sprintf(byte_602141, "%06x", qword_602178);
              v4 = strlen(byte_602141);
              MD5(byte_602141, v4, byte_602110);
              for ( i = 0; i <= 15; ++i )
                sprintf(&byte_602120[2 * i], "%02x", (unsigned __int8)byte_602110[i]);
              printf(off_602080, byte_602120);
              exit(0);
            }
          }
        }
      }
    }
LABEL_2:
    printf("password : ");
    __isoc99_scanf("%s", &s1);
    if ( strlen(&s1) > 0x10 )
    {
      puts("the password must be less than 16 character");
      exit(1);
    }
    for ( j = 0; j < strlen(&s1); ++j )
      *(&s1 + j) ^= 6u;
    if ( !strcmp(&s1, a7yq2hryrn5yJga) )
    {
      v3 = strlen(&s1);
      MD5(&s1, v3, byte_602110);
      for ( k = 0; k <= 15; ++k )
        sprintf(&byte_602120[2 * k], "%02x", (unsigned __int8)byte_602110[k]);
      printf(off_602080, byte_602120);
      exit(0);
    }
    puts("bad password!");
    exit(0);
  }
  printf("password : ");
  __isoc99_scanf("%s", &s1);
  if ( strlen(&s1) > 0x10 )
  {
    puts("the password must be less than 16 character");
    exit(1);
  }
  for ( m = 0; m < strlen(&s1); ++m )
  {
    *(&s1 + m) ^= 2u;
    ++*(&s1 + m);
    *(&s1 + m) = ~*(&s1 + m);
  }
  if ( !memcmp(&s1, &unk_6020B8, 9uLL) )
  {
    for ( n = 0; n < strlen(aO6uH); n += 2 )
    {
      aO6uH[n] ^= 0x45u;
      aO6uH[n + 1] ^= 0x26u;
    }
    puts(aO6uH);
  }
  else
  {
    puts("bad password!");
  }
  return 0LL;
}
// 4006A0: using guessed type __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD);
// 4006E0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 602148: using guessed type __int64 qword_602148;
// 602150: using guessed type __int64 qword_602150;
// 602158: using guessed type __int64 qword_602158;
// 602160: using guessed type __int64 qword_602160;
// 602178: using guessed type __int64 qword_602178;

//----- (0000000000400DE0) ----------------------------------------------------
void __fastcall init(unsigned int a1, __int64 a2, __int64 a3)
{
  signed __int64 v3; // rbp
  __int64 i; // rbx

  v3 = &off_601DF8 - &funcs_400E29;
  init_proc();
  if ( v3 )
  {
    for ( i = 0LL; i != v3; ++i )
      (*(&funcs_400E29 + i))();
  }
}
// 601DF0: using guessed type __int64 (__fastcall *funcs_400E29)();
// 601DF8: using guessed type __int64 (__fastcall *off_601DF8)();

//----- (0000000000400E54) ----------------------------------------------------
void term_proc()
{
  ;
}

// nfuncs=33 queued=10 decompiled=10 lumina nreq=0 worse=0 better=0
// ALL OK, 10 function(s) have been successfully decompiled

Análisis estático

Anti-debug

Si la función ptrace retorna -1, significa que el programa está siendo depurado y redirige a LABEL_2.

if (ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1) {
    goto LABEL_2;
}

Cálculos y validaciones

El programa espera al menos 5 argumentos (nombre del programa y cuatro números enteros). Si se proporcionan los cuatro números enteros, se realizan los siguientes cálculos:

if (-24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
    && 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
    && 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
    && -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613)

Esto es un sistema de ecuaciones lineales mondo y lirondo que debe ser resuelto para encontrar los valores correctos de qword_602148, qword_602150, qword_602158 y qword_602160. Una vez resuelto el sistema de ecuaciones se realiza la operación:

 qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;

A continuación se pasa el resultado de la variable qword_602178 a hexadecimal y se genera su hash MD5.

Solución en Python

Lo más rápido en esta ocasión es usar Python, pero esto se puede resolver hasta con lápiz y papel 😉

from sympy import symbols, Eq, solve
import hashlib

# Definir las variables
A, B, C, D = symbols('A B C D')

# Definir las ecuaciones
eq1 = Eq(-24*A - 18*B - 15*C - 12*D, -18393)
eq2 = Eq(9*C + 18*(A + B) - 9*D, 4419)
eq3 = Eq(4*C + 16*A + 12*B + 2*D, 7300)
eq4 = Eq(-6*(A + B) - 3*C - 11*D, -8613)

# Resolver el sistema de ecuaciones
solution = solve((eq1, eq2, eq3, eq4), (A, B, C, D))

# Verificar si se encontró una solución
if solution:
    print("Solución encontrada:")
    print(solution)

    # Obtener los valores de A, B, C y D
    A_val = solution[A]
    B_val = solution[B]
    C_val = solution[C]
    D_val = solution[D]

    # Mostrar los valores encontrados
    print(f"A = {A_val}")
    print(f"B = {B_val}")
    print(f"C = {C_val}")
    print(f"D = {D_val}")

    # Calcular qword_602178
    qword_602178 = C_val + B_val * A_val - D_val
    qword_602178 = int(qword_602178)  # Convertir a entero de Python
    print(f"qword_602178 = {qword_602178}")

    # Convertir qword_602178 a una cadena en formato hexadecimal
    byte_602141 = f"{qword_602178:06x}"
    print(f"byte_602141 (hex) = {byte_602141}")

    # Calcular el MD5 de la cadena
    md5_hash = hashlib.md5(byte_602141.encode()).hexdigest()
    print(f"MD5 hash = {md5_hash}")

    # Generar la flag
    flag = f"FLAG-{md5_hash}"
    print(f"Flag = {flag}")

else:
    print("No se encontró una solución.")

Al ejecutar el script veremos algo como esto:

Solución encontrada:
{A: 227, B: 115, C: 317, D: 510}
A = 227
B = 115
C = 317
D = 510
qword_602178 = 25912
byte_602141 (hex) = 006538
MD5 hash = 21a84f2c7c7fd432edf1686215db....
Flag = FLAG-21a84f2c7c7fd432edf1686215db....

ThisIsLegal.com – Realistic Challenge 1

por ·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
 Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Introducción

 Realistic Challenge 1: Your friend tried to purchase some software off a company. But after he paid they decided to increase it’s price by a large amount. They are now refusing to send it him. Get them back by getting their most expensive software a lot cheaper than they intended you to.
Lo que nos dice el enunciado del reto a groso modo es que debemos cambiar el precio del software antes de comprarlo.

Firebug

 Para resolver este reto basta con tener instalado el complemento para Firefox «Firebug«. Abrimos la web y echamos un vistazo con Firebug
Vemos un parámetro oculto que se llama «amount» y que tiene un valor de 100$. Basta con cambiarlo a 00,01$ y ya tenemos resuelto el reto.

Links

Stego X – Chunk

por ·Sin comentarios

Intro

Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir que para cada reto hay una herramienta que nos da la solución. En la entrada anterior os comenté que mi fondo de armario son steganabara y stegsolve aunque cuando la imagen es PNG, una herramienta de uso obligatorio es TweakPNG.

La víctima

imagen original del reto

Nos enfrentamos a una imagen PNG de 112KB (115477 bytes) con una resolución de 300×225 píxeles. A priori llama la atención el elevado tamaño VS la baja resolución, lo que aviva nuestras sospechas de que esos KB extras se deban a que haya insertado otro archivo en su interior.

Chunk

Los archivos PNG tienen la peculiaridad de que están divididos en secciones (chunks) en la que algunas son críticas como IHDR (cabecera), IDAT (la imagen) e IEND (final) y otras muchas secundarias como por ejemplo tEXt (para insertar texto). Al explorar el archivo con TweakPNG vemos la cabecera, varios chunks de texto, muchos IDAT que he combinado en uno para mejorar el análisis y la sección final. Si os fijáis, al combinar los IDAT ha cambiado el tamaño del PNG de 115447 a 110893 bytes aunque en este caso sigue siendo un tamaño elevado.

aspecto original de los chunks
aspecto de los chunks tras combinar todos los IDAT en uno

Llama la atención el chunk cHRm de 12595 bytes del que TweakPNG ya nos avisa que no reconoce su contenido. Cargamos la imagen en un editor hexadecimal y buscamos la palabra «Great» que es el texto que hay justo antes del chunk cHRm que nos interesa.

detalle del chunk cHRm en editor hexadecimal

La búsqueda da sus frutos ya que el chunk parece que está formado por un archivo mp4. A partir de aquí tenemos varias opciones, para mí la más limpia es con un editor hexadecimal apuntar los offsets de inicio y fin del chunk y crear un archivo nuevo con el contenido. Otra opción es exportar el chunk desde TweakPNG con extensión mp4 y borrar los bytes del nombre del chunk con un editor hexadecimal, de lo contrario no podréis reproducir el mp4.

nombre del chunk a borrar para que funcione el mp4

Hecho esto, al escuchar el mp4 obtenemos la solución del reto.

Enlaces

Nota: si algo os pide clave es deurus.info