Autor
|
Tema: KeyGenME fary - v1.0 (Leído 11,111 veces)
|
Geovane
Desconectado
Mensajes: 208
|
¡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
|
|
« Última modificación: 11 Enero 2019, 04:10 am por Geovane »
|
En línea
|
|
|
|
MCKSys Argentina
|
Bueno, ya que hay un bruteforcer publicado, dejo el mío, también en MASM: ; 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!
|
|
|
En línea
|
MCKSys Argentina "Si piensas que algo está bien sólo porque todo el mundo lo cree, no estás pensando."
|
|
|
Geovane
Desconectado
Mensajes: 208
|
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
|
|
« Última modificación: 11 Enero 2019, 04:26 am por Geovane »
|
En línea
|
|
|
|
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 .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
|
|
« Última modificación: 11 Enero 2019, 04:56 am por EdePC »
|
En línea
|
|
|
|
Geovane
Desconectado
Mensajes: 208
|
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
|
|
« Última modificación: 11 Enero 2019, 14:19 pm por Geovane »
|
En línea
|
|
|
|
Yuki
Desconectado
Mensajes: 80
El error es una muestra de la incompetencia.
|
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. 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 TVqAAAEAAAAEABAA//8AAEABAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQokAAAAAAAAAABQRQAATAEEAEjMOFwAAAAAAAAAAOAADiELAQFIAAIAAAAGAAAAAAAAABAAAAAQAAAAIAAAAABAAAAQAAAAAgAAAQAAAAAAAAAEAAAAAAAAAABQAAAABAAAmD8AAAIAQAAAEAAAABAAAAAAAQAAAAAAAAAAABAAAAAAIAAAbQAAAAAwAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC50ZXh0AAAAWAAAAAAQAAAAAgAAAAQAAAAAAAAAAAAAAAAAACAAAGAuZWRhdGEAAG0AAAAAIAAAAAIAAAAGAAAAAAAAAAAAAAAAAABAAABALmlkYXRhAAAUAAAAADAAAAACAAAACAAAAAAAAAAAAAAAAAAAQAAAwC5yZWxvYwAACAAAAABAAAAAAgAAAAoAAAAAAAAAAAAAAAAAAEAAAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADHASMNVieVWV1GLRQiLTQzTyFlfXsnCCABVieVWV1GLRQiLTQzTwFlfXsnCCABVieVWV1GLRQiLTQzT4FlfXsnCCABVieVWV1GLRQiLTQzT6FlfXsnCCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUCAAAAEAAAAEAAAABAAAACggAAA4IAAASCAAAAQQAAAZEAAALhAAAEMQAABeIAAAWSAAAGMgAABoIAAAAQAAAAIAAwBGQmluLmRsbABmUk9SAGZST0wAZlNITABmU0hSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ¡Saludos!
|
|
« Última modificación: 11 Enero 2019, 20:15 pm por Yuki »
|
En línea
|
|
|
|
Geovane
Desconectado
Mensajes: 208
|
¡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
|
|
« Última modificación: 11 Enero 2019, 20:23 pm por Geovane »
|
En línea
|
|
|
|
fary
|
Ya que esta esto resuelto, diré que la contraseña maestra es: f4RyKeY
|
|
|
En línea
|
Un byte a la izquierda.
|
|
|
Geovane
Desconectado
Mensajes: 208
|
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.
|
|
« Última modificación: 12 Enero 2019, 21:15 pm por Geovane »
|
En línea
|
|
|
|
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: .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
|
|
|
En línea
|
|
|
|
|
Mensajes similares |
|
Asunto |
Iniciado por |
Respuestas |
Vistas |
Último mensaje |
|
|
KeygenMe en D
Ingeniería Inversa
|
avesudra
|
2
|
2,263
|
24 Enero 2013, 17:05 pm
por avesudra
|
|
|
[KeygenMe] Android KeygenMe
Ingeniería Inversa
|
Høl¥
|
0
|
2,045
|
30 Enero 2013, 04:46 am
por Høl¥
|
|
|
[Keygenme] Aspid
Ingeniería Inversa
|
mr.blood
|
8
|
5,953
|
21 Marzo 2013, 17:42 pm
por tincopasan
|
|
|
[KeygenMe] Matrix
« 1 2 3 »
Ingeniería Inversa
|
mr.blood
|
28
|
12,532
|
29 Marzo 2015, 12:37 pm
por ViejoMajara
|
|
|
Fary
Foro Libre
|
Stelio Kontos
|
1
|
1,813
|
17 Febrero 2021, 17:37 pm
por el-brujo
|
|