Aquí os dejo esto que acabo de crear :P
https://turbobit.net/6aa4wraynw7x.html
El hosting tiene una poquita publicidad, pero es el único que he encontrado que me deja subir archivos sin registrarme.
Reglas del reto, crear un KeyGen :o
saludos!
Lo he revisado y es bastante sencillo.
Especial para quienes comienzan y desean afianzar el conocimiento de instrucciones ASM (es 1 sola la que interesa aquí).
Como siempre, recuerden realizar los retos siempre en VMs!!
Saludos!
PD: @fary Gracias por el aporte!
EDIT:
Con el tamaño del ejecutable, lo podrías haber colocado en base64 en vez de subirlo a ese host... :xD
Hola!!
Yo también lo he revisado y te felicito por tu trabajo. Es muy buen aporte para aprender y lo ¡has escrito directamente en ASM!
Good work! @Fary
PD. Por supuesto lo he guardado por si en un futuro desapareciera...
Cierto, el host es una M. Si consigo sacar tiempo intentaré subir aunque sea a Mega los crackmes que tengo de elhacker
Gracias por vuestros comentarios :)
No se me habia ocurrido McSys Argentina... ventajas de programar en ASM ::)
Ahí va...
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
Y la web para reconvertirlo a archivo....
https://emn178.github.io/online-tools/base64_decode_file.html
obviamente hay que renombrarlo a .exe jeje
un saludo!!
Gracias por compartir este reto Fary, pero también quería añadir un avance que tuve al momento de estar crackeando tu keygenme. Y resulta que encontré el call (Rutina) dónde se encuentra el algoritmo que genera los seriales válidos y genuinos, pero no pude crackear ese algoritmo.
VA: 0040111F (Windows 7 Only)
Adjunto tu keygenme parcheado para poder registrarse con cualquier serial:
http://tutorialeslinuxywindows.tk/FaryKeyGenME!_parcheado_aceptacualquierserialFlyNDSkyGMFnDElhackerNET.rar
Que Dios te bendiga, protega y acompañe.
;-)
fary
{Gracias por el desafío, por el tiempo dedicado a ello, por compartir
En primer lugar, usted no tiene algo que hacer "Keygen", el valor es fijo.
Correcto desafío = Escribir la función inversa del serial
Para keygen verdadero cada equipo genera diferente clave
Me gustó mucho, voy a desarrollar la solución.}
FlyNDSkyGMFnD
{ No hacer parche ! }
MCKSys Argentina
{ buena idea de base64}
Saludos
Todos los seriales son validos para todos los equipos :rolleyes:
PD: Alguien consiguió una contraseña válida?
saludos!!!
Me apunto el desafió. Estoy siguiendo los tutoriales de Ricardo Narvaja y cuando los termine lo intentare :D
Cita de: fary en 9 Enero 2019, 07:31 AM
PD: Alguien consiguió una contraseña válida?
El serial más corto que cumple con la condición es
RzLX3 :P
Por supuesto, un keygen debería enumerar muchos más... ;D
Saludos!
Cita de: MCKSys Argentina en 9 Enero 2019, 19:59 PM
El serial más corto que cumple con la condición es RzLX3 :P
Por supuesto, un keygen debería enumerar muchos más... ;D
Saludos!
Que bueno!!! :P bruteforce, ¿No?, yo probé con 4 caracteres y no me saco ni una válida jajajaja :(
Por ahora les va dando caña el
señor Argentina, ¿Quién mas tiene su serial válido? :laugh: :laugh: :laugh:
Cita de: fary en 9 Enero 2019, 20:10 PM
Que bueno!!! :P bruteforce, ¿No?, yo probé con 4 caracteres y no me saco ni una válida jajajaja :(
Si. Al ser una validación "acumulativa", es complejo conseguir un serial en base a la constante...
Pero no digo más, que la idea es que participe más gente. ;)
Saludos!
Saludos,
- Yo me hago líos con el "criptoanálisis" :xD, ya sé cual es el algoritmo que se usa, pero "darle vuelta" >:D es otra cosa. Supongo que también me inclinaré por Brute-Force, jeje no se si llamarle KeyGen a algo que se limita a mostrar unos cuantos Seriales HardCode al azar :xD.
- Voy a desempolvar mi viejo Disco Duro BackUp de hace años para extraer los Tutoriales de Assemble de RVLCN, muy buenos por cierto: PDF, Videos, Ficheros Fuente, etc. Tengo que armar desde cero el RadASM para empezar a hacer el Brute-Force en Assemble, así repaso este lenguaje.
------------------------------------------
- Por cierto, me he fijado de que la Web de Ricardo Narvaja no está el curso de RVLCN completo, solo están del 1 al 6, y tengo entendido de que el curso va del 1 al 8
- Para aprender Assemble en mi caso me ha ido bien con el curso de RVLCN y el de Programación de Virus de zeroPad, buenas bases para entender Assemble y hacer Keygen, Patch. Loader, etc.
-----------------------------
RVLCN Curso de ASM desde Cero + Tools: http://www.ricardonarvaja.info/WEB/OTROS/DE%20LA%20LISTA%20MASM32-RADSM/
Programación de Virus por zeroPad: http://www.ricardonarvaja.info/WEB/OTROS/PROGRAMACION%20DE%20VIRUS/
Referencia práctica de instrucciones Assemble por Caos Reptante (muy bueno): http://www.ricardonarvaja.info/WEB/CURSO%20NUEVO/TEORIAS%20NUMERADAS/000-100/001-ASSEMBLER%20por%20CAOS%20REPTANTE.zip
CheatSheet de instrucciones Assemble: http://www.jegerlehner.ch/intel/IntelCodeTable_es.pdf
Hola EdePe, en teoría no se podría hacer keygen, obviamente :xD. Pero puse eso porque quería que el objetivo fuese que el atacante encontrara un serial válido ya que parchearlo es una chorrada... si esta hecho en FASM XD tiene 50 líneas de código por no decirte 30 :laugh:.
De todas formas, ánimo y intenta obtener el serial para registrar tu programa ;-)
saludos.
Cita de: fary en 9 Enero 2019, 20:10 PM
bruteforce, ¿No?, yo probé con 4 caracteres y no me saco ni una válida jajajaja :(
Yo probé ayer un código rápido por fuerza bruta y con 5 caracteres (estuvo un buen rato) tampoco encontró nada válido. No sé si se podrá estudiar bien la rutina e intentar acotar para encontrar seriales válidos. Para los que empiezan es muy entretenido e interesante...
¡Hola
La ingeniería inversa sobre la solución de MCKSys Argentina .
---------------------------------------------------------------------------------
RzLX3
0xF6C53333
-33 >33
F6C53300 rol 0x0D = A6601ED8
-58 >58
A6601E80 rol 0x0D = 03D014CC
-4C >4C
03D01480 rol 0x0D = 0290007A
-7A >7A
02900000 rol 0x0D = 00000052 > 52
---------------------------------------------------------------------------------
ror > rol + > -
Saludos
Cita de: karmany en 10 Enero 2019, 13:39 PM
Yo probé ayer un código rápido por fuerza bruta y con 5 caracteres (estuvo un buen rato) tampoco encontró nada válido. No sé si se podrá estudiar bien la rutina e intentar acotar para encontrar seriales válidos. Para los que empiezan es muy entretenido e interesante...
Probando los chars desde 20h a 7Eh, sólo 2 soluciones de 5 chars. Si nadie postea más nada, en unos días posteo el source de mi bruteforce en ASM para 5 chars (hacerlo para n chars es sólo agregar más código.)
Saludos!
EDIT: El brute es para 5 chars..
¿Ola, fuerza bruta?
No necesita fuerza bruta :)
más un ejemplo, la lógica va a aparecer.
@ RyLx#
# 23 F6C53310
rol A6621ED8
x 78 A6621E60
rol 43CC14CC
L 4C 43CC1480
rol 82900879
y 79 82900800
rol 01001052
R 52 01001000
rol 02000020
20 02000000
rol 00000040 =@
Saludos
Cita de: Geovane en 10 Enero 2019, 22:50 PM
¿Ola, fuerza bruta?
No necesita fuerza bruta :)
más un ejemplo, la lógica va a aparecer.
@ RyLx#
# 23 F6C53310
rol A6621ED8
x 78 A6621E60
rol 43CC14CC
L 4C 43CC1480
rol 82900879
y 79 82900800
rol 01001052
R 52 01001000
rol 02000020
20 02000000
rol 00000040 =@
Saludos
Muy bueno! Haz un keygen (
sin que use fuerza bruta) y postéalo!
Saludos!
Geovane ;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-) Buenísimo!!!!!!! para nada me lo esperaba :rolleyes:
- O_o? No entiendo que pasa, jeje, mi programita en Masm32 se supone que debe de mostrar un serial válido aplicando fuerza bruta, pero me manda respuestas incorrectas :xD
- Incluso usando OllyDbg y depurando el programita me arroja un "serial válido", los registros concuerdan (edi), el Dump muestra el serial, pero si lo pruebo o incluso vuelvo a repasar con el mismo serial generado (new origin here) no funciona :xD
- Lo he subido a PasteBin: https://pastebin.com/E38JfmPk he puesto como semilla: FSMMIvH, luego al ejecutar el programita me dice que FUWFoRL es un serial válido, pero no lo es XD. Será que hay algo mal en mi PC, o un bug o error mio?
¡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
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!
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
- 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 :xD
.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
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
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!
¡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
Ya que esta esto resuelto, diré que la contraseña maestra es: f4RyKeY :laugh:
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.
- 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
La verdad que esta clase de retos te distrae de la tareas cotidianas, así que he decidido distraerme un poco y hacer un keygen (generador de claves) para todos los seriales SOLO de 6 caracteres. Este keygen no lo he querido programar (sería muy sencillo) y lo voy a hacer escrito para que todo el mundo sin conocimientos de programación pueda usarlo.
Solo he utilizado caracteres imprimibles desde el valor 20hex hasta el 7Fhex, los demás los he obviado.
¿Cómo lo he resuelto? Pues hice directamente en OllyDBG fuerza bruta, me fui a cenar y después de cenar estudié los resultados que el script me dejó en memoria, así que es un keygen post-estudio.
Empecemos.
1º CARÁCTER
El que el usuario quiera. Voy a poner, por ejemplo, la letra v que equivale a 76hex. Los guiones siguientes, aunque puedan valer, en este caso no sirven y los pongo únicamente para mostrar los caracteres pendientes.
v-----
Antes de continuar con los siguientes caracteres, es necesario saber que según el valor hex de este primer caracter, existen 3 zonas.
PRIMERA ZONA. ZONA 4A. Del valor 68h al 7Fh (a.i.)
SEGUNDA ZONA. ZONA 4B. Del valor 1Fh al 7Fh (a.i.)
TERCERA ZONA. ZONA 4C. Del valor 1Fh al 27h (a.i.)
Para que sea sencillo de entender, pongo el ejemplo de la letra v=76h. El valor 76h puede estar:
-En la zona 4A (Del 68h al 7Fh) y
-En la zona 4B (Del 1Fh al 7Fh) pero no puede estar en la zona 4C.
2º y 5º CARACTERES
Estos caracteres son siempre fijos y corresponden a las letras R y X. Por lo tanto, ya tenemos:
vR--X-
3º CARÁCTER
Solo puede ser o los dos puntos : o la letra zeta minúscula (z).
Solo hay una condición:
Si el primer carácter es par, el 3º carácter es la letra zeta minúscula (z), si no : .
Por lo tanto, el primer carácter es la v que equivale a 76hex y es par, así que el 3º carácter es una z. Ya tenemos:
vRz-X-
4º CARÁCTER
El 4º carácter corresponde con la Zona. Así que podemos tener 2 casos para ZONA 4A (J) y ZONA 4B (K).
vRzJX-
vRzKX-
6º Y ÚLTIMO CARÁCTER
Realizamos las operaciones de cifrado del serial hasta el último carácter, así:
PRIMER SERIAL: vRzJX-
v = 76h
R = 52h
z = 7Ah
J = 4Ah
X = 58h
EDI = 0 ; EDI = 00000000h
ADD EDI, 76; EDI = 00000076h
ROR EDI, D ; EDI = 03B00000h
ADD EDI, 52; EDI = 03B00052h
ROR EDI, D ; EDI = 02901D80h
ADD EDI, 7A; EDI = 02901DFAh
ROR EDI, D ; EDI = EFD01480h
ADD EDI, 4A; EDI = EFD014CAh
ROR EDI, D ; EDI = A6577E80h
ADD EDI, 58; EDI = A6577ED8h
ROR EDI, D ; EDI = F6C532BBh
Y ahora tan sencillo como restar la semilla F6C53333 con ese valor:
F6C53333 - F6C532BB = 78hex
6º carácter = 78h (x), por lo tanto, primera contraseña válida:
vRzJXx
SEGUNDO SERIAL: vRzKX-
v = 76h
R = 52h
z = 7Ah
K = 4Bh
X = 58h
EDI = 0 ; EDI = 00000000h
ADD EDI, 76; EDI = 00000076h
ROR EDI, D ; EDI = 03B00000h
ADD EDI, 52; EDI = 03B00052h
ROR EDI, D ; EDI = 02901D80h
ADD EDI, 7A; EDI = 02901DFAh
ROR EDI, D ; EDI = EFD01480h
ADD EDI, 4A; EDI = EFD014CBh
ROR EDI, D ; EDI = A65F7E80h
ADD EDI, 58; EDI = A65F7ED8h
ROR EDI, D ; EDI = F6C532FBh
F6C53333 - F6C532FB = 38hex = 8
Segundo serial válido: vRzKX8
Otro ejemplo rápido sin tanta explicación:
3-----
solo está en ZONA 4B: 3--K--
2 caracteres fijos: 3R-KX-
impar: 3R:KX-
F6C53333 - F6C532D9 = 5Ah = Z
Serial válido: 3R:KXZ
Cita de: Geovane en 12 Enero 2019, 18:40 PM
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
Si te fijas, compruebo si estoy siendo debugeado dos veces... una llamando a la propia API y otra vez lo compruebo mientras estoy creando los objetos de la ventana :) aunque creo que nadie se tomo cuenta de eso...
Aquí os el código fuente!
format PE GUI 4.0
entry start
include 'win32w.inc'
section '.text' code readable executable
start:
invoke GetModuleHandle,0
mov [wc.hInstance],eax
invoke LoadIcon,0,IDI_APPLICATION
mov [wc.hIcon],eax
invoke LoadCursor,0,IDC_ARROW
mov [wc.hCursor],eax
invoke RegisterClass,wc
test eax,eax
jz error
invoke IsDebuggerPresent,0 ; ACTIVAR despues de depurar
cmp eax,0
jne end_loop
invoke CreateWindowEx,0,_class,_title,WS_VISIBLE+WS_DLGFRAME+WS_SYSMENU,128,128,256,100,NULL,NULL,[wc.hInstance],NULL
test eax,eax
jz error
msg_loop:
invoke GetMessage,msg,NULL,0,0
cmp eax,1
jb end_loop
jne msg_loop
invoke TranslateMessage,msg
invoke DispatchMessage,msg
jmp msg_loop
error:
invoke MessageBox,NULL,_error,NULL,MB_ICONERROR+MB_OK
end_loop:
invoke ExitProcess,[msg.wParam]
proc WindowProc uses ebx esi edi, hwnd,wmsg,wparam,lparam
cmp [wmsg],WM_DESTROY
je .wmdestroy
cmp [wmsg],WM_CREATE
je .wmcreate
cmp [wmsg],WM_COMMAND
je .wmcommand
jmp .defwndproc
.wmcommand:
xor eax, eax
xor edx, edx
mov eax, [_buttonregistry]
mov edx, [lparam]
cmp eax,edx
jne .finish
invoke GetWindowTextA,[_editregistry],password,10
stdcall checkpass,password ; Comprobamos la contraseña.
jmp .finish
.defwndproc:
invoke DefWindowProc,[hwnd],[wmsg],[wparam],[lparam]
jmp .finish
.wmcreate:
invoke CreateWindowExA,WS_EX_APPWINDOW,_labelclass,_labeltext,WS_CHILD+WS_VISIBLE,10,10,150,20,[hwnd],NULL,[wc.hInstance],NULL
mov edx,dword[fs:0x18]
push edx
invoke CreateWindowExA,WS_EX_APPWINDOW,_editclass,0,WS_CHILD+WS_VISIBLE+WS_BORDER,115,10,125,20,[hwnd],NULL,[wc.hInstance],NULL
mov [_editregistry],eax
pop edx
mov edx,dword[edx+0x30]
push edx
invoke CreateWindowExA,WS_EX_APPWINDOW,_buttonclass,_buttonname,WS_CHILD+WS_VISIBLE,10,40,230,20,[hwnd],NULL,[wc.hInstance],NULL
mov [_buttonregistry],eax
pop edx
movsx edx,byte[edx+2]
mov [dbg],edx ; Si esta debugger presente
jmp .finish
.wmdestroy:
invoke PostQuitMessage,0
xor eax,eax
.finish:
ret
endp
proc checkpass,pass
mov esi, [pass]
compute_hash:
xor edi, edi ;EDI = 0
xor eax, eax ;EAX = 0
cld
compute_hash_again:
lodsb ;AL = BYTE[ESI] , ESI = ESI + 1
test al, al
jz compute_hash_finished
ror edi, 0xD
add edi, eax
jmp compute_hash_again
compute_hash_finished:
;EDI = El Hash de la cadena
cmp edi,0xF6C53333
jne salircheck
mov eax, [dbg]
cmp eax,1
je salircheck
invoke MessageBoxA,0,_goodpass,_goodtitle,MB_OK+MB_ICONINFORMATION
salircheck:
ret
endp
section '.data' data readable writeable
_class TCHAR 'KeyGenMe Fary',0
_title TCHAR 'Fary KeyGenME - 1.0',0
_error TCHAR 'Startup failed.',0
_goodpass db 'Enhorabuena, superaste el reto!ahora el keygen ;)',0
_goodtitle db 'Good Boy',0
_buttonregistry dd ?
_buttonclass db 'BUTTON',0
_buttonname db 'Registrar',0
_editregistry dd ?
_editclass db 'EDIT',0
_labelclass db 'STATIC',0
_labeltext db 'Fary Password: ',0
password rb 11
dbg dd 0
wc WNDCLASS 0,WindowProc,0,0,NULL,NULL,NULL,COLOR_BTNFACE+1,NULL,_class
msg MSG
section '.idata' import data readable writeable
library kernel32,'KERNEL32.DLL',\
user32,'USER32.DLL'
include 'api\kernel32.inc'
include 'api\user32.inc'
También quiero aclarar que el código que crear los hashes no es mio! pero me parecio interesante >:D >:D >:D
https://foro.elhacker.net/programacion_visual_basic/asmvb6invoke_llamas_apis_sin_declararlas_kinvokebas-t290072.0.html
Aunque claro, veté tu a saber quién sea el autor porque por aquí también aparece el mismo hash :xD
https://github.com/debasishm89/x86-Assembly/blob/master/speaking%20shell%20code.asm
Entre otras páginas...
Fary , usted tiene razón, hay segunda verificación, en la confirmación de la contraseña
felicitaciones.
karmany , "Este keygen no lo he querido programar (sería muy sencillo)"
eso es un poco divertido
Si es simple muestre la lógica de creación de una contraseña!
Lo que mostró, basta mirar en el EDI, en el debugger!
Saludos
Bueno, he creado este simple generador de claves para 6 caracteres, usando solo la zona 4B. Unicamente el usuario debe escribir el primer carácter de (20hex hasta 7Fhex) y el resto lo calcula el programa.
Para no usar registros EDI ni nada por el estilo, he escrito la fórmula en un Excel. Os lo pongo en descarga.
(http://subirimagen.me/uploads/20190113044317.png)
Descarga del Excel:
https://mega.nz/#!i5YwSYLI!koy5ybfMZG1Op0v7-Ui8c3NdNIsvjU5R2tQW_4pOfuQ (https://mega.nz/#!i5YwSYLI!koy5ybfMZG1Op0v7-Ui8c3NdNIsvjU5R2tQW_4pOfuQ)
Un saludo.
No puedo dedicar nada más de tiempo a este keygen. Espero el keygen de Geovane, que es muy interesante lo que explicó.
Gracias karmany por compartir, realmente tiempo es un problema, cuando el desafío exige mucho tiempo de nosotros
Aquí esta Keygen
Parece que "reinventó la rueda", con las funciones ....
El propósito y analizar lo más profundo posible en la lógica
Pero tiene como mejorar mucho el código.
Agradecimientos especiales a todos los que participaron en este desafío.
Aprendí mucho, con todos.
¿Quién puede mejorar el código, favor dice
function HexToBin(Hex: String): String;
var
Bin: String;
k: Byte;
Begin
Bin:='';
For k:=1 to Length(Hex) do
if Hex[k]='0' then Bin:=Bin+'0000'
else if Hex[k]='1' then Bin:=Bin+'0001'
else if Hex[k]='2' then Bin:=Bin+'0010'
else if Hex[k]='3' then Bin:=Bin+'0011'
else if Hex[k]='4' then Bin:=Bin+'0100'
else if Hex[k]='5' then Bin:=Bin+'0101'
else if Hex[k]='6' then Bin:=Bin+'0110'
else if Hex[k]='7' then Bin:=Bin+'0111'
else if Hex[k]='8' then Bin:=Bin+'1000'
else if Hex[k]='9' then Bin:=Bin+'1001'
else if Hex[k]='A' then Bin:=Bin+'1010'
else if Hex[k]='B' then Bin:=Bin+'1011'
else if Hex[k]='C' then Bin:=Bin+'1100'
else if Hex[k]='D' then Bin:=Bin+'1101'
else if Hex[k]='E' then Bin:=Bin+'1110'
else if Hex[k]='F' then Bin:=Bin+'1111';
HexToBin:=Bin;
End;
function BinToHex(Bin: String): String;
var
k: Byte;
s: String;
Hex: String;
Begin
Hex:='';
While Length(Bin) mod 4<>0 do Bin:='0'+Bin;
For k:=0 to Length(Bin) div 4 -1 do
Begin
s:=Copy(Bin,k*4+1,4);
if s='0000' then s:='0'
else if s='0001' then s:='1'
else if s='0010' then s:='2'
else if s='0011' then s:='3'
else if s='0100' then s:='4'
else if s='0101' then s:='5'
else if s='0110' then s:='6'
else if s='0111' then s:='7'
else if s='1000' then s:='8'
else if s='1001' then s:='9'
else if s='1010' then s:='A'
else if s='1011' then s:='B'
else if s='1100' then s:='C'
else if s='1101' then s:='D'
else if s='1110' then s:='E'
else if s='1111' then s:='F';
Hex:=Hex+s;
End;
BinToHex:=Hex;
End;
function StrToHex(Str: String): Integer;
var
Hex:Integer;
Begin
if (str.Length=7) Then
Begin
str:='0' + str;
end;
if (str.Length=6) Then
Begin
str:='00' + str;
end;
Hex:= (strToInt(copy(Str,1,1))*128);
Hex:= Hex + (strToInt(copy(Str,2,1))*64);
Hex:= Hex + (strToInt(copy(Str,3,1))*32);
Hex:= Hex + (strToInt(copy(Str,4,1))*16);
Hex:= Hex + (strToInt(copy(Str,5,1))*8);
Hex:= Hex + (strToInt(copy(Str,6,1))*4);
Hex:= Hex + (strToInt(copy(Str,7,1))*2);
Hex:= Hex + (strToInt(copy(Str,8,1))*1);
StrToHex:=Hex;
end;
function shLeft(Str:String;N:integer): String;
var
s:String;
Begin
s:=copy(Str,N+1,32-N)+copy(Str,1,N);
shLeft:=s;
end;
procedure TForm1.Button1Click(Sender: TObject);
var
A,B:String;
C:Integer;
Label
rotacionar,ciclo;
//F6C53333 Caractere >=32 <=126 $20 $7E
begin
A:= 'F6C53333';
B:= HexToBin(A);
ciclo:
// 8 bits
C:= strToHex(copy(B,25,8));
IF (C>31) and (C<127) Then
Begin
Edit1.text:= (intTohex(C,2)) + Edit1.text ;
B:= (Copy(B,1,24)) + '00000000';
GOTO rotacionar;
end; // fin 8 bits
//7 bits
C:= strToHex(copy(B,26,7));
IF (C>31) and (C<127) Then
Begin
Edit1.text:= (intTohex(C,2)) + Edit1.text;
B:= (Copy(B,1,25)) + '0000000';
GOTO rotacionar;
end; //fin 7 bits
//6 bits (Con 6 bits positivos no passa valor $7E No precisa testar con 5)
C:= strToHex(copy(B,27,6));
IF (C>31) and (C<127) Then
Begin
Edit1.text:= (intTohex(C,2)) + Edit1.text;
B:= (Copy(B,1,26)) + '000000';
GOTO rotacionar;
end; //fin 6 bits
rotacionar:
IF ((Copy(B,1,32)) <> '00000000000000000000000000000000') Then
begin
B:=shLeft(B,13);
goto ciclo;
//Showmessage(B);
end;
end;
Esto se basa en la lógica que ya he posteado
F6C53333 11110110110001010011001100110011
110011 33---3
11110110110001010011001100000000
10100110011000000001111011011000 58---X
10100110011000000001111010000000
00000011110100000001010011001100 4C---L
00000011110100000001010010000000
00000010100100000000000001111010 7A---z
00000010100100000000000000000000
0000001010010 52---R
RzLX3
En texto, función, después al final .......
Function HexToStr(s: String): String;
Var i: Integer;
Begin
Result:=''; i:=1;
While i<Length(s) Do Begin
Result:=Result+Chr(StrToIntDef('$'+Copy(s,i,2),0));
Inc(i,2);
End;
End;
Showmessage(hexTostr(Edit1.text));
Fary ¡Muy bueno su codigo, excelente desafío !!!!!
Actualización 1
Usted puede intentar con otro valor.
Pero el valor necesita estar correctamente construido, mediante función inversa!
Para evitar este error, antes rotacionar:
¿Por qué con 6 bits no encontró valor válido !!!!
Showmessage('¡Hummmm, valor incorrecto !!!!!');
rotacionar:
IF ((Copy(B,1,32)) <> '00000000000000000000000000000000') Then
begin
B:=shLeft(B,13);
goto ciclo;
//Showmessage(B);
end;
Gracias, Saludos
¡¡Excelente trabajo Geovane!!
Tu punto de vista ha sido muy instructivo e interesante.
Gracias a tu idea se me ha ocurrido lo siguiente que no se si se podrá generalizar para otros caracteres o tamaños de serial.
Partimos del último carácter que me invento: 8 que es 38hex
Inicio: F6C53333
F6C53333 - 38 = F6C532FB; //38hex es el carácter 8
ROL F6C532FB, D = A65F7ED8
Y ahora voy restanto 7/8 bits como tu mencionas:
A65F7ED8 - 58 = A65F7E80; //58hex es el caracter X
ROL A65F7E80, D = EFD014CB
EFD014CB - 4B = EFD01480; //4Bhex es el caracter K
ROL EFD01480, D = 02901DFA
02901DFA - 7A = 02901D80; //7Ahex es el caracter z
ROL 02901D80, D = 03B00052
03B00052 - 52 = 03B00000; // 52hex es el caracter R
ROL 00000076, D = 00000076
00000076 - 76 = 00000000; //76hex es el caracter v
Por lo tanto, el serial válido es vRzKX8
Un saludo
Good work!
Y así es como, de un reto "simple", se puede aprender mucho...
Felicitaciones y agradecimientos para todos los involucrados.
Saludos!
Hello friends
Hasta ahora tenemos un keygen que busca el primer serial válido.
Tenemos uno que busca mediante fuerza bruta
¿Dónde está lo que busca la contraseña correcta?
Recuerda a los amigos (ver los bits !!!)
Tengo la solución, voy a publicar si nadie encuentra.
Saludos.
Cita de: fary en 11 Enero 2019, 23:10 PM
Ya que esta esto resuelto, diré que la contraseña maestra es: f4RyKeY :laugh:
;-)