¡Hola!

Me he llevado una agradable sorpresa al ver esta mañana la presentación del código. Veo una nota en la que me indica que los códigos deben ir en etiquetas GeSHi. Me imagino que será esta .La próxima vez irá así.

MCKSys, tienes razón. En cuanto vuelva del paseo matinal la pongo en aquél foro.

Saludos.

¡Hola!

Por fin he conseguido hacer el keygen en Python. Lo presento a continuación. Como soy novato, me imagino que será manifiestamente mejorable.

En el keygen se pone el nombre de 9 letras y el programa devuelve una solución, así como la suma de los valores ASCII de las letras de la clave tomadas de tres en tres, por si se quieren calcular fácilmente otras soluciones a mano.

Es esto:

_______________________________________________________

print 'El nombre y la clave deben tener 9 letras cada uno'
print 'No se admiten acentos, diéresis ni letras especiales'
print 'Se pueden poner mayusculas o minusculas mezcladas'
 
 
def longEntrada(n):
    c= str(n).__len__()
    return c
 
long =5
 
while long != 9:
    nombre = raw_input('Introduce un nombre de 9 letras: ')
    long = longEntrada(nombre)
 
c1nom = int(ord(nombre[0]) + ord(nombre[3]) + ord(nombre[6]))
c2nom = int(ord(nombre[1]) + ord(nombre[4]) + ord(nombre[7]))
c3nom = int(ord(nombre[2]) + ord(nombre[5]) + ord(nombre[8]))
 
n=1
x=1
 
while (n != 314875 and x != 367):
 
    for x in range(195,368):
        if n==314875:
            break        
        y = 195
        for y in range(195,367):
            if n==314875:
                break   
            z = 366
            while (z >= 195 and n != 314875):
                if n==314875:
                    break                
                n = c1nom*x + c2nom*y + c3nom*z
                z = z-1
 
if x == 367:
    print n, 'No tiene clave'
 
else:
    print n, 'Las sumas de claves son:'
    print x-1, y-1, z+1
    x=x-1
    y=y-1
    z=z+1
 
def sacaClaves(a):
    if a % 3 == 0:
        m=n=p= a/3
    else:
        m=n=a//3
        p=a-m-n
 
    if ((97>m>90) or (97>p>90)):
        m=n=m-10
        p=p+20
    u=chr(m)
    v=chr(n)
    w=chr(p)
 
    cla=u+v+w
    return cla
 
clave1= sacaClaves(x)
clave2= sacaClaves(y)
clave3= sacaClaves(z)
 
clave = clave1+clave2+clave3
 
print 'La clave para %s es:'%nombre
print clave
 
input()

_____________________________________________________________

Efectivamente hay nombres que no tienen clave, pero los que la tienen es múltiple. En el keygen sólo saco una.

Por fin respiro.

Saludos.

PS. MCKSys, espero haberme ganado el  fuente del cracme4.

Mod: los codigos deben ir en etiquetas GeSHi

¡Hola!

Mediante tanteos en la hoja que había preparado en EXCEL he sacado la clave (o una de las posibles claves) para majarilla. Es abPyxzzzz, pero me he pasado un buen rato con ello.

He reducido las incógnitas a 3, cada una de ellas compuesta por la suma de los valores ASCII de cada fila de la matriz de la clave, pero no consigo dar con la formula mágica para poder preparar un keygen.

En este caso:
                    m a j                     a b P
                    a  r  i                     y x z
                    l   l  a                     z z z

(m+a+l).(a+b+P) + (a+r+l).(y+x+z)+(j+i+a).(z+z+z) = 4CDFB (Hexa)= 314875

Dejaré reposar el cerebro con otras cosas y, si no sale antes alguien por ahí con la solución, seguiré dandole vueltas a este endiablado problema matemático que nos has planteado, mr.blood.

Saludos

¡Hola!

Con los datos que habéis ido reseñando, he comprobado que disponiendo el nombre y la clave en forma matricial de 3x3 y multiplicándolas, la suma de los valores de la matriz obtenida es el valor que se compara con 4CDFB.

Como ya lo habéis dicho, tanto el nombre como la clave deben de tener una longitud de 9 caracteres, y ambas deben ser de letras, mayormente minúsculas, ya que los números dan unos resultados bajos. No sé si al final se podrá poner algún número.

Por ejemplo: Nombre majarilla, Clave zurututza.

Matrices    maj     zur
                ari       utu
                lla        tza
Sustituimos cada letra por su valor ASCII y multiplicamos ambas matrices. Sumamos todos los elementos de la matriz resultante y el resultado es el valor a comparar. Yo lo he hecho en EXCEL y me concuerdan los resultados.

Ahora voy a repasar mis antiguos conocimientos de matrices para ver si, conociendo el valor del producto de dos matrices y una de ellas se puede sacar la otra.

Saludos

¡Hola!

Aunque Flamer lo había explicado resumido, pero perfecto, aquí envío un tutorial para alguien que sea más novato que yo. Es el primero que preparo para los demás, o sea que espero vuestra comprensión.

TUTORIAL PARA RESOLVER EL CRACKME

Corremos el crackme.exe para ver cómo funciona. Sale una ventana en la que nos indica: ”Introduzca usuario”. Metemos un nombre y pulsamos enter.

En la misma ventana aparece “Introduzca serial”. Metemos un número y pulsamos enter.

Como parece que no acertamos, desaparece la ventana.

Miramos cómo está escrito y si está empaquetado con RDG Packer Detector. Nos indica que está escrito en C++ y no detecta packer alguno.

Lo abrimos con OLLY parcheado para su detección por nombre y con todas las opciones de HideOD marcadas.

Lo corremos con F9. Nos sale la ventana anteriormente citada, introducimos nombre y clave como antes, pero ahora en la misma ventana nos indica: “Buen intento”.

Pulsamos Debug y Restart y nos lleva al inicio en 401220. Botón Derecho (BD), Search for y All referenced text strings. Vemos “Correcto” y “Buen intento” en dos direcciones distintas. Vamos a esa zona en el debugger.

Brujuleamos por la zona y observamos que en 4013C0 hay CALL 401290, luego un CMP EAX,1 y un JNZ al “Buen intento” si EAX no es 1.

En 4013D3 hay un CALL 4012E9, dos líneas más abajo un CMP [EBP-208],AL y un JNZ al otro “Buen intento” si [EBP-206] y AL no son iguales.

A la vista de lo anterior ponemos BP  en los dos CALL y pulsamos F9. Nos aparece la ventana, la rellenamos como siempre y al dar al segundo  enter se nos para en 4013C0.

Entramos en el CALL con F7 y estudiamos lo que hace. Primero mide la longitud (cantidad de caracteres) del nombre y, si es 6 o menos, retorna EAX=0. En caso de que el nombre tuviese una longitud mayor que 6, mide la longitud (cantidad de cifras) de la clave y si es 6 o menos, retorna EAX=0. Si la longitud de la Clave también es superior  a 6, retorna EAX=1. Cuando sale del CALL, si EAX=0 salta al segundo “Buen intento” y finaliza. Si EAX =1, sigue adelante.

Lo finalizamos, eliminamos el BP en 4013C0 y reiniciamos el crackme, pero ahora meteremos un nombre y una clave de longitud superior a 6. Se nos para en 4013D3.
Entramos en el CALL con F7 y lo estudiamos. Aquí  vemos que suma los valores ASCII de todas las cifras de la Clave excepto la más significativa (la de la izquierda), la hace un XOR 32, al resultado le resta 0A y a la cifra resultante la compara con 64. Si es mayor que 64, a la resultante le hace las mismas operaciones, XOR 32 y resta de 0A, y así hasta que da un resultado menor o igual que 64, en el que sale del CALL poniendo en EAX este valor.

A la salida, en 4013E4, compara EAX con el valor ASCII  de la primera letra de la Clave. Si son iguales nos imprime “Correcto” y termina, y si no, nos larga el primero de los “Buen intento” y termina.

Forma de solución rápida: Reiniciar, poner un BP en 4013E4, correrlo, poner nombre y clave de más de 6 signos y darle a enter. Parará en 4013E4. En el espacio del OLLY donde explica lo que hace, verás la primera letra de la clave que has metido y la que tenía que ser. Pones esta letra la primera de tu nombre y más de seis letras después, y la misma clave que has usado para obtenerla anteriormente y te aparecerá “Correcto”.

La otra, prepararte un Keygen. Yo lo he hecho en Python 2.7.
Las operaciones del segundo CALL en el keygen las  puedes hacer en decimal, sustituyendo 32 por 50, 64 por 100 y 0A por 10.
 

¡Hola!

Soy novato en Python y jamás hubiese imaginado que se pudiesen producir salidas aleatorias sin proponerlas explícitamente.

Asunto solventado.

Saludos.

¡Hola!

Por fin me he hecho un keygen muy simple en Python 2.7 y funciona. Lo que pasa es que me gustaría hacer algo parecido a la ventana del crackme4 o a la del keygen de Thunder, es decir que en uno de los buzones (o como se llamen) colocase el nombre y en el otro me apareciese la clave. ¿Dónde puedo estudiar o ver cómo se gestionan este tipo de ventanas?

Por otra parte no entiendo lo suficientemente bien el IMUL para poder poner límites a la longitud del nombre a introducir, si es que fuese preciso para que no salten errores o excepciones al meter un nombre muy largo. Me imagino que la clave no podrá ocupar más de 64 bits, pero no sé cuántos bits son para el signo, así que de momento no hago nada al respecto.

Saludos

¡Hola!

En la lección 30 del manual de R.Narvaja, en la penúltima página, aparece un ejemplo en el que, para crear una salida con el nombre y salario de cada empleado,  hace lo siguiente:


Se entiende perfectamente, pero al imprimir el orden en el que salen es:


Por más vueltas que le doy al tema no consigo averiguar el por qué de esta ordenación. ¿Podría alguien aclararlo?

Saludos

¡Hola!

Ya le estoy tomando el pulso a WING y lo que me pasaba era que, en una importación de módulos, seguía manteniendo como módulo principal uno que había utilizado con anterioridad y siempre me aparecía cuando menos lo esperaba. Le quité la prioridad,  lo eliminé del Proyecto y se resolvió el asunto.

En cuanto al Python 2.7 creo que tuve problemas con él, probablemente por mi ignorancia en su utilización. Lo volveré a probar.

Saludos

¡Hola!

Efectivamente, he usado el editor de PYTHON y, ¡por fin!, he podido pasar de la lección 29.

Saludos