KeyGenME fary - v1.0

[Geovane]

¡Hola
más una oportunidad, para más personas comprender la lógica


F6C53333      11110110110001010011001100110011
                                                                         110011 33---3
                     11110110110001010011001100000000
                     10100110011000000001111011011000 58---X
                                                               
                     10100110011000000001111010000000
                     00000011110100000001010011001100 4C---L
                                                                 
                     00000011110100000001010010000000
                     00000010100100000000000001111010 7A---z
                                                     
                     00000010100100000000000000000000
                                                           0000001010010 52---R  

RzLX3

consome bits <= 8
girar 13 bits a la izquierda
de nuevo consumir
gire, consuma hasta 1 byte sobrando

Si nadie lo hace, voy a publicar en unos días

Gracias y Saludos

[MCKSys Argentina]

Bueno, ya que hay un bruteforcer publicado, dejo el mío, también en MASM:

Código (asm) [Seleccionar] Expandir


; Esto lo meti en una DLL, ya que usando WinASM me resulta mas fácil hacer una DLL, cargarla con Olly y campiar EIP a la funcion que hice.
; El bruteforcing es mas lento por Olly, pero puedo poner BP's rapido.
.386

.MODEL flat,stdcall

OPTION CASEMAP:NONE

Include windows.inc
Include user32.inc
Include kernel32.inc
include masm32.inc


IncludeLib user32.lib
IncludeLib kernel32.lib
includelib masm32.lib


.DATA
Serial db 01Fh              ; Buffer donde vamos a generar el string a probar
pad     db 10h dup(00h)     ; Espacio que sigue al buffer (16 bytes) que nos permite ir creando un string mas largo cada vez, sin tener que allocar nada
sep     db 00Dh, 00Ah, 000h ; Usado para ir separando los seriales encontrados
seriales db 400h dup(00h)   ; Buffer donde guardaremos los seriales hallados.

TestHello proc uses esi edi
; Prueba hasta 5 chars (desde 20h hasta 7Eh)
seguir:
    mov eax, offset Serial
    add byte ptr [eax], 1
    cmp byte ptr [eax], 7Eh
    jbe calc

    mov byte ptr [eax], 20h
    .if byte ptr [eax+1] == 0           ; Sintaxis MASM para no tener que hacer los cmp a mano.
       mov byte ptr [eax+1], 1Fh
    .endif   
    add byte ptr [eax+1], 1
    cmp byte ptr [eax+1], 7Eh
    jbe calc

    mov byte ptr [eax+1], 20h
    .if byte ptr [eax+2] == 0
       mov byte ptr [eax+2], 1Fh
    .endif   
    add byte ptr [eax+2], 1
    cmp byte ptr [eax+2], 7Eh
    jbe calc

    mov byte ptr [eax+2], 20h
    .if byte ptr [eax+3] == 0
       mov byte ptr [eax+3], 1Fh
    .endif   
    add byte ptr [eax+3], 1
    cmp byte ptr [eax+3], 7Eh
    jbe calc

    mov byte ptr [eax+3], 20h
    .if byte ptr [eax+4] == 0
       mov byte ptr [eax+4], 1Fh
    .endif   
    add byte ptr [eax+4], 1
    cmp byte ptr [eax+4], 7Eh
    jbe calc
   
    jmp salida
   
calc:
    xor edi,edi
    xor eax, eax
    mov esi, offset Serial
bucle:
    lodsb
    test al,al
    jz compara
    ror edi,0Dh
    add edi, eax
    jmp bucle
compara:
    cmp edi, 0F6C53333h
    jnz seguir
    invoke szCatStr, offset seriales, offset sep        ; MASM macro szCatStr. Une 2 szStrings y guarda el resultado en la 1era.
    invoke szCatStr, offset seriales, offset Serial
    jmp seguir
   
salida:
    ret   
TestHello endp


Saludos!

[Geovane]

Gracias MCKSys Argentina

Muy elegante su código

Recordando, mi solución no es fuerza bruta.
Precaución sólo para utilizar caracteres imprimibles
Ya que se escribirá serial.

Muchas gracias fary, me encantó este desafío

saludos

[EdePC]

- Anda es cierto, solo hay que hacer la inversa, como no hay pérdida de bits se puede reversear, siendo bruto y eliminando (restando) siempre el último byte para después hacerle un ROL 13, esto hasta obtener 00000000, un serial válido es: PxÌØ3

- Como dice Geovane, se puede sacar <= 8 para obtener un Ascii normal, pero el ya lo puso  

Código (asm) [Seleccionar] Expandir

.386
.model flat, stdcall
option casemap: none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data?
password db 5 dup(?)

.code
keymaker:

mov   eax, 0F6C53333h    ; Constante a reversear
lea   edi, password + 4 

inicio:
mov   [edi], al  ; Guardando el serial
dec   edi        ;   generado

movzx ebx, al
sub   eax, ebx
rol   eax, 0Dh
cmp   eax, 0
jne   inicio

invoke ExitProcess, 0

end keymaker

[Geovane]

EdePC
Esto va bien, pero necesita trabajar en bits, en el byte.

1-  sustrae 8 bits de la derecha.
    si el valor es mayor que 1F, sustrae 7 bits

2-  ahora gire 13 bits a la izquierda

3-  Repita 1e 2, hasta 1 byte.

Saludos

[Yuki]

Muy interesante el desafío, es una lástima que no haya podido crear un Keygen, la gracia de este ejemplo es que solo aplica un ror y un add en busca de bits específicos.

Espero con ansias la solución de Geovane.

Para no dejar únicamente un comentario dejo acá el algoritmo que utiliza el programa en VB6.

Código (vb) [Seleccionar] Expandir


Private Declare Function fROR Lib "FBin.dll" (ByVal Num As Long, ByVal pos As Long) As Long
Function EncriptAlgorithm(s As String, Optional ByVal target As Long = &HF6C53333) As Boolean
    Dim barr() As Byte
    Dim edi As Long
    Dim i As Long
    barr = StrConv(s, vbFromUnicode)
    For i = 0 To UBound(barr)
        edi = fROR(edi, &HD)
        edi = edi + barr(i)
    Next
    EncriptAlgorithm = (edi = target)
End Function

FBin.dll

Código [Seleccionar] Expandir

TVqAAAEAAAAEABAA//8AAEABAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQokAAAAAAAAAABQRQAATAEEAEjMOFwAAAAAAAAAAOAADiELAQFIAAIAAAAGAAAAAAAAABAAAAAQAAAAIAAAAABAAAAQAAAAAgAAAQAAAAAAAAAEAAAAAAAAAABQAAAABAAAmD8AAAIAQAAAEAAAABAAAAAAAQAAAAAAAAAAABAAAAAAIAAAbQAAAAAwAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC50ZXh0AAAAWAAAAAAQAAAAAgAAAAQAAAAAAAAAAAAAAAAAACAAAGAuZWRhdGEAAG0AAAAAIAAAAAIAAAAGAAAAAAAAAAAAAAAAAABAAABALmlkYXRhAAAUAAAAADAAAAACAAAACAAAAAAAAAAAAAAAAAAAQAAAwC5yZWxvYwAACAAAAABAAAAAAgAAAAoAAAAAAAAAAAAAAAAAAEAAAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHASMNVieVWV1GLRQiLTQzTyFlfXsnCCABVieVWV1GLRQiLTQzTwFlfXsnCCABVieVWV1GLRQiLTQzT4FlfXsnCCABVieVWV1GLRQiLTQzT6FlfXsnCCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUCAAAAEAAAAEAAAABAAAACggAAA4IAAASCAAAAQQAAAZEAAALhAAAEMQAABeIAAAWSAAAGMgAABoIAAAAQAAAAIAAwBGQmluLmRsbABmUk9SAGZST0wAZlNITABmU0hSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

¡Saludos!

[Geovane]

¡Hola

el keygen esta listo

1-  sustrae 8 bits de la derecha.
    si el valor es mayor que 1F, sustrae 7 bits

2-  ahora gire 13 bits a la izquierda

3-  Repita 1e 2, hasta 1 byte.


es suficiente escribir, cualquier lenguaje.
si nadie es capaz, voy a publicar en días.
espero que más gente participe antes

Una sugerencia, mire a bits, no bytes.

F6C53333      11110110110001010011001100110011
                                                                          110011 33---3
                      11110110110001010011001100000000
                      10100110011000000001111011011000 58---X
                                                               
                      10100110011000000001111010000000
                      00000011110100000001010011001100 4C---L
                                                                 
                      00000011110100000001010010000000
                      00000010100100000000000001111010 7A---z
                                                     
                      00000010100100000000000000000000
                                                            0000001010010 52---R 

RzLX3

saludos

[fary]

Ya que esta esto resuelto, diré que la contraseña maestra es: f4RyKeY   

[Geovane]

Fue un gran desafío

Hasta se ha considerado no posible hacer Keygen !
Como una función hash, sólo ida, no vuelve.

Pero, todo resume en mira a bits, no el byte !!!!

observación.

ya que hizo en asm, podía escribir isDebuggerPresent() en asm, no api.
mov     eax, large fs:30h
movzx   eax, byte ptr [eax+2]
retn


Fue el mejor reto que he participado.
Parece simple, pero complejo!
MCKSys Argentina me motivó a continuar, después de publicar un serial válido.
Voy a hacer la solución del keygen.

Gracias, Saludos.

[EdePC]

- Me parece que la clave está en eliminar los últimos 8 bits para que queden en cero, luego hacer el ROL 13 y repetir hasta que todo quede en 00000000, luego todos los bits eliminados será los bytes del password, Esto es lo más rápido, pero se podría obtener bytes no normales, por ejemplo el password válido más corto es: PxÌØ3

- Sin embargo, para obtener un password Ascii común, habría que ir eliminando (restando) de siete en siete bits:

Código (asm) [Seleccionar] Expandir

.386
.model flat, stdcall
option casemap: none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data?
password db 5 dup(?)

.code
keymaker:

mov   eax, 0F6C53333h    ; Constante a reversear
lea   edi, password + 4 

inicio:
movzx ebx, al
shl   bl, 1      ; Descarta el primer bit
shr   bl, 1      ;   para trabajar en ASCII de 7 bits

mov   [edi], bl  ; Guardando el serial
dec   edi        ;   generado

sub   eax, ebx
rol   eax, 0Dh
cmp   eax, 0
jne   inicio

invoke ExitProcess, 0

end keymaker

-- Devuelve: RzLX3 que es el Ascii normal más corto, y PxÌØ3 es todavía más corto (menor) pero no es Ascii normal.

- Con respecto al Keygen, y teniendo en cuenta que al final lo que hay que hacer convertir la constante 0F6C53333 a 00000000 utilizando el algoritmo inverso: restar los últimos 8 o siete bits y luego hacer el ROL 13, repetir hasta obtener 00000000 y guardar los bits restados que serán los bytes del password (ordenados al revés). Supongo que se puede restar menos bits, ya no ocho o siete, sino seis o menos, esto haría un password con más bytes debido a que serán más vueltas al algoritmo.

-- Lo que me gustaría es que el KeyGen pida una semilla (Nombre de usuario o algo así), luego aplicar el algoritmo no-inverso (el original) a la semilla para ver que valor devuelve (valor de EDI), luego aplicar el algoritmo inverso hasta obtener 00000000 sobre la semilla trabajada (valor de EDI que había quedado), de esta manera obtener seriales válidos como: EdePC - XXXXXX