Foro de elhacker.net

Os quiero proponer unos cuantos retos simples de c++ para practicar. Se puede usar de todo menos buscar el resultado por internet y copiar el resultado.

La idea es que quien quiera participar que juegue y quien no y quiera aprender que pueda tomar los codigos como ejemplos

El codigo mas corto o el codigo mas rápido ganara un bónus.

El ganador no ganara nada y el perdedor tampoco y los puntos no sirven para nada.


=======================================

1-Un programa que cuente los caracteres que tiene un texto previamente introducido por el usuario (parece más fácil de lo que es)

ejemplo de entrada: "ho la" ejemplo salida:el texto tiene 5 caracteres

1 punto
____________________________________

2- Crear programa que lea el contenido de un archivo de texto.

2 puntos
________________________________
3- Un programa que diga el numero mas grande. El usuario ha de insertar 4 numeros separados por un espacio.

3 puntos

________________________________

4- Un programa que muestre la palabra mas pequeña en el orden alfabético. El usuario insertara 4 palabras

40 puntos

__________________________

5- Un creador de diccionarios para fuerza bruta

50 puntos

____________________________

6- Un programa que te apague el pc manera larga. (el programa tendra que ir haciendo los clicks como si fuera una persona)

60 puntos

__________________________

7- Un programa que te de una lista de los procesos prescindibles que mas consumen.

70 puntos

__________________________

8- Un crackeador de md5 ( a partir de un hash buscar una palabra que tenga el mismo hash).

80 puntos


__________________________

9- Un programa que corra en background y cambie el nombre de todas las ventanas que se llamen "hola" a "adios" .

75 puntos

__________________________

10- Un programa que escriba al revés las palabras. .

Entrada: hola
Salida: aloh



15 puntos
__________________________

11- Un programa que al introducirle tu data de nacimiento te diga los días, meses y semanas que faltan para tu próximo cumpleaños  

20 puntos

__________________________

12- Un programa que haga diversos rombos de 2 * n -1 lineas como en el siguiente ejemplo  

Entrada: 4
SAlida:  
    *
  ***
 *****
*******
 *****
  ***
   *

25 puntos


__________________________

13- Un programa que haga lo siguiente:  decidir si lo que se le ha dado realmente es un sudoku (comprobar que realmente tenga una unica solucion y tenga el tamaño correcto) ((idea de do-while))  

35p

PD:El formato del sudoku puede ser cualquiera siempre y cuando el progrma permita al user ingresar el sudoku por algún lado ,que no sea el codigo fuente.

__________________________

14- Un programa que genere 15200 numeros aleatorios y diga el número más grande que ha generado.  

11p

__________________________

15- Un programa que haga la serie de Fibonacci ( el programa tiene que imprimir por pantalla hasta el numero 30 en la serie de Fibonacci).  + INFO SOBRE LA SERIE:http://es.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci (http://es.wikipedia.org/wiki/N%C3%BAmero_de_Fibonacci)

11p

__________________________

15-(Similar al anterior)Crear un programa que obtenga el numero fi a partir de la serie de Fibonacci (el bucle tiene que tener un minimo de 30 ciclos) .

15p
------------------------------------------------------------------------------



1º overxfl0w13(339p)
2º do-while (275p)
3º 0xdani (137p)
4º leosansan (115p)
5º Puntoinfinito (79p)
6º za.asi (71p))
7º ankora45 (66p)
8º werever19 (46p)
9º Dato000 (5p)
10º Ecfisa (1p)

He echo el 3ro, aun no lo he probado, supongo que algo mal estara (eso me pasa por ir siempre a lo dificil xD) Y además aun no se mucho... :)

#include <iostream>
 
using namespace std;
 
int main()
{
int a = 99999999, b= -999, x = 0, y = 0, grande = 0, var = 0, final = 0;
int i = 0, z = 0;
 
    cout << "Ingrese el 4 numeros por espacio" << endl;
    cin >> x;
    cin >> y;
    cin >> i;
    cin >> z;
    if ( x > y)
    {
         grande = x;
    }
    else
    {
        grande = y;
    }
    if (i > z)
    {
          var = i;
    }
       else
    {
           var = z;
    }
    if (grande > var)
    {
        grande = final;
    }
    else
    {
        var = final;
    }
    cout << "El mayor numero que has puesto es : " << final;
    cin.get();
    return 0;
}

propongan retos más dificiles aqui hay gente que sabe muchisimo y casi siempre se une a los retos  ::)

cuando tenga tiempo ire añadiendo estos son básicos

Para gente para mi. Estoy de acuerdo con estos retos!!. No siempre hay que poner dificiles, cuando uno esta aprendiendo estos retos son los mejores que hay!!

Pongo el código de la 3 simplificado:

#include <iostream>
 
using namespace std;
 
int main()
{
int a = 0, b = 0, c = 0, d = 0, mayor = 0;
cout << "Ingresa los 4 numeros por espacio : ";
cin >> a >> b >> c >> d;
if ((a > b) && (a > c) && (a > d))
mayor = a;
if ((b > a) && (b > c) && (b > d))
mayor = d;
if ((c > b) && (c > a) && (c > d))
mayor = c;
if ((d > b) && (d > c) && (d > a))
mayor = d;
cout << "Numero mayor : " << mayor;
cin.sync();
cin.get();
return 0;
}
 

Mejoró más ehh xDD

Hola.

Yo voy por el más fácil: El 1  ::)

#include <stdio.h>
#include <ctype.h>
 
int main(int argc, char* argv[]) {
  char frase[100];
  int i=0;
  const char *num[10] = {"cero","uno","dos","tres","cuatro","cinco",
                         "seis","siete","ocho","nueve" };
  printf("Frase: ");
  fgets(&frase,100,stdin);
 
  while (frase[i]) {
    if (isdigit(frase[i]))
      printf("%s ",num[frase[i]-48]);
    i++;
  }
 
  getchar();
  return 0;
}
 

Edito: Disculpas, no reparé que era C++ :-(

#include <iostream>
 
using namespace std;
 
int main(int argc, char* argv[]) {
  char frase[100];
  int i=0;
  const char *num[10] = {"cero","uno","dos","tres","cuatro","cinco",
                         "seis","siete","ocho","nueve" };
  cout << "Frase: ";
  cin >> frase;
 
  while (frase[i]) {
    if (isdigit(frase[i]))
      cout << num[frase[i]-48] << " ";
    i++;
  }
 
  while(cin.get()!='\n');
  cin.get();
  return 0;
}
 

Saludos.

teoricamente era de c++ pero bueno si peudes hazlo con c++
ademas da error
a.c: In function `main':
a.c:10: warning: passing arg 1 of `fgets' from incompatible pointer type

Hola Stakewinner00.

Si... me había percatado de la confusión (C++) ya estaba agregando el código.

En realidad es una advertencia, la inclusión de '&' fue un despiste mío :(, la línea debería ser:

 fgets(frase,100,stdin);

Un Saludo. ::)

Estos retos son muy faciles, en realidad practicamente se lleva los puntos el que lo vea primero :silbar:

ya pero como ire colocando mas retos habra un reto que valdra 30 puntos y entonces el qeu quiera ganar tendra k hacer el 100% de los retos

Me parece bien, estare pendiente :)

EI: juntando mensajes.

El reto nº 6 no me parece bien, esta orientado a windows y yo estoy en ubuntu.

EI: juntando mensajes.

Reto nº5:

#include <fstream>
 
using namespace std;
 
int main()
{
char vars[6];
vars[5]='\n';
ofstream diccionario("diccionario");
for(vars[0]='a'; vars[0]<'Z'; vars[0]++)
 {
   for(vars[1]='a'; vars[1]<'Z'; vars[1]++)
   {
     for(vars[2]='a'; vars[2]<'Z'; vars[2]++)
      {
        for(vars[3]='a';vars[3]<'Z'; vars[3]++)
          for(vars[4]='a';vars[4]<'Z'; vars[4]++ )
           diccionario.write(vars, 6);
      }
   }
 }
diccionario.close();
return 0;
}
 

Ahora mismo no puedo probarlo, pero creo que funcionara.

Saludos.

EI: juntando mensajes.

Reto nº 2:
 

#include <fstream>
#include <iostream>
 
using namespace std;
 
int main(int argc, char* argv[])
{
ifstream file(argv[1]);
char buf[5];
while(!file.eof())
{
 file.read(buf, 5);
 cout<<buf<<endl;
}
file.close();
return 0;
}
 

Lo mismo con este, ahora mismo no puedo probarlo pero creo que funcionara.

oxdai modifique un poco los puntos y el de windows lo puse generico si puede ser comprueba que funcionen bien tus codes y luego te sumo los puntos. Y si quieres cuando funcione bien te paso el k yo tenia.

EI: juntando mensajes.

ecfis de lo que se trataba es de lo siguiente

entrada

HOLA

salida

el texto tiene 4 caracteres o simplemente un 4

otro ejemplo

entrada
________

hola k tal estas

salida
________

el texto tiene 16 caracteres o un 16

Si quieres lo compruebo yo, pero no puedo ahora mismo, y ademas dado que eres tu el que administra los puntos deberias probarlos tu para comprobar que realmente funcionan no? En cuanto al de windows me parece bien :)

el k tu pusiste uno falta decir el archivo k tiene k leer y el otro no escrive nada

En el de leer el archivo si te fijas el archivo a leer es el primer argumento.  Ahora miro el otro.

el de leer los archivos funciona bien pero un .txt con hola imprime holaÏ■(, de todas formas lo acepto por que si que lee el archivo pero intenta arreglar eso si pudes.

Te paso por mp el k yo tenia

Ok, ahora cuando consiga solucionar el de fuerza bruta lo intento con el de leer el archivo.

Los puntos se deberían de dar a los que hagan el código más corto!

buena idea

Entiendo, pero por el texto de la consigna "Un programa que diga el nombre de dígitos que tiene el texto introducido ", no interpreté que se tratase de la cantidad de caracteres de la cadena ingresada.

Entonces:

#include<iostream>
 
using namespace std;
 
int main() {
  string texto;
 
  cout << "Texto: ";
  getline(cin, texto);
  cout << "El texto tiene " << texto.length() << " caracteres.";
  cin.get();
  return 0;
}
 

Saludos.

EI: juntando mensajes.

Hola.

Para el punto 4 podría ser:

#include <iostream>
#define MAX_PALABRAS 4
 
using namespace std;
int main() {
  string vec[MAX_PALABRAS], min;
 
  cout << "Ingrese " << MAX_PALABRAS << " palabras" << endl;
  cout << "-----------------" << endl;
 
  min.assign(255,255);
  for(int i = 0; i < MAX_PALABRAS; i++) {
    cout << "Palabra " << i+1 << " :";
    cin >> vec[i];
    if (vec[i] < min)
      min = vec[i];
  }
  cout << endl << "Primer palabra por orden alfabetico: " << min;
 
  while(cin.get()!='\n');
  cin.get();
  return 0;
}
 

Saludos.

1.

#include <stdio.h>
#include <string.h>
 
#define DIM 100
 
int main(int argc, char *argv[])
{
    char texto[DIM],*cifras[]={"cero","uno","dos","tres","cuatro","cinco","seis","siete","ocho","nueve"};
    int i;
 
    do{
        if(!fgets(texto,DIM,stdin))
            return 0;
 
        for(i = 0 ; texto[i] ; i++)
            if(texto[i] >= '0' && texto[i] <= '9')
                printf("%s\n",cifras[texto[i] - '0']);
 
    }while(texto[strlen(texto) - 1] != '\n');
 
    return 0;
}
 

#include <iostream>
#include <string>
 
using namespace std;
 
int main(int argc, char *agrv[])
{
    char *cifras[] = {"cero","uno","dos","tres","cuatro","cinco","seis","siete","ocho","nueve"};
    string texto;
 
    getline(cin,texto);
 
    for(int i = 0 ; i < texto.length() ; i++)
        if(texto[i] >= '0' && texto[i] <= '9')
            cout << cifras[texto[i] - '0'] << endl;
 
    return 0;
}
 

Y mas eficiente:

#include <iostream>
#include <string>
 
using namespace std;
 
int main(int argc, char *agrv[])
{
    char *cifras[] = {"cero","uno","dos","tres","cuatro","cinco","seis","siete","ocho","nueve"};
    string texto;
 
    getline(cin,texto);
 
    //no se dice nada sobre el orden 
    for(int i = texto.length() - 1 ; i >= 0 ; i--)
        if(texto[i] >= '0' && texto[i] <= '9')
            cout << cifras[texto[i] - '0'] << endl;
 
    return 0;
}
 

2. Faltan datos: ¿Nombre del fichero? ¿Tipo de fichero? (binario/texto) ¿Leer completo, por bloques de una cantidad determinada de bytes, por palabras...?

3.

#include <stdio.h>
 
int main(int argc, char *argv[])
{
    int max, num,i;
 
    scanf("%d",&max);
 
    for(i = 1 ; i < 4 ; i++)
    {
        scanf("%d", &num);
        if(num > max)
            max = num;
    }
 
    printf("Max: %d\n",max);
 
    return 0;
}
 

4.

#include <iostream>
#include <string>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    string min, palabra;
    int i;
 
    cin >> min;
 
    for(i = 1 ; i < 4 ; i++)
    {
        cin >> palabra;
 
        if(palabra < min)
            min = palabra;
    }
 
    cout << min;
 
    return 0;
}
 

5. Faltan datos: ¿Alfabeto? ¿Longitud de la clave?

perdon  por los que se confundieron con el punto 4 fue error mio.

Estoy mirando los codigos y sumando los puntos.

do-while, en los que faltan datos es libre

ecfisa, en tu codigo falta un include despues lo añado

2.

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
    FILE *f;
    char *contenido;
    unsigned long longitud;
 
    f=fopen("algunfichero","rb");
 
    fseek(f,0,SEEK_END);
 
    if(!(contenido = malloc(longitud = ftell(f))))
        return -1;
 
    fseek(f,0,SEEK_SET);
 
    fread(contenido,longitud,1,f);
 
    fclose(f);
 
    free(contenido);
 
    return 0;
}
 

5.
Este crashea con alfabetos de mas de 18 caracteres y longitud 6

/*
 *  linea de comandos:
 *      nombreprograma alfabeto longitud
 */
 
#include <iostream>
#include <list>
#include <string>
#include <cstring>
#include <cstdlib>
 
using namespace std;
 
unsigned long convertir(char *s);
void bruteforce(list<string> &resultado,char *alfabeto,unsigned long longitud);
 
int main(int argc, char *argv[])
{
    list<string> resultado;
    unsigned long l;
 
    if(argc != 3)
    {
        cerr << argv[0] << " alfabeto longitud" << endl;
        return -1;
    }
 
    if(!(l = strlen(argv[1])))
    {
        cerr << argv[0] << " alfabeto longitud" << endl;
        return -1;
    }
 
 
    //eliminamos caracteres repetidos del alfabeto
    for(int i = 0 ; i < strlen(argv[1]) ; i++)
        if(strchr(argv[1] + i + 1 , argv[1][i]))
        {
            memmove(argv[1] + i ,argv[1] + i  + 1, (l--) - i );
            i--;
        }
 
    //nos aseguramos de que el segundo argumento sea numerico
    for(int i = 0 ; argv[2][i] ; i++)
        if(argv[2][i] < '0' || argv[2][i] > '9')
        {
            cerr << argv[0] << " alfabeto longitud" << endl;
            return -1;
        }
 
    bruteforce(resultado,argv[1],convertir(argv[2]));
 
    for(list<string>::iterator it = resultado.begin() ; it != resultado.end() ; it++)
        cout << (*it) << endl;
 
    return 0;
}
 
unsigned long convertir(char *s)
{
    unsigned long ret = 0;
 
    for(int i = 0 ; s[i] ; i++)
    {
        ret *= 10;
        ret += s[i] - '0';
    }
 
    return ret;
}
 
void bruteforce(list<string> &resultado,char *alfabeto,unsigned long longitud)
{
    static string cadena;
    static unsigned long posicion = 0;
 
    if(posicion == longitud)
    {
        //si hemos llegado a la ultima posicion almacenamos la variacion
        resultado.push_back(cadena);
        return;
    }
 
    //si es la primera llamada damos la longitud deseada a la cadena
    if(posicion == 0)
        cadena.resize(longitud);
 
    //para cada una de los caracteres del alfabeto
    for(int i = 0 ; alfabeto[i] ; i++)
    {
        cadena[posicion] = alfabeto[i]; //asignamos a la posicion correspondiente el caracter del alfabeto.
 
        //avanzamos una posicion
        posicion++;
 
        //y calculamos el siguiente caracter
        bruteforce(resultado , alfabeto , longitud);
 
        //volvemos a la posicion original
        posicion--;
    }
 
    //posicion termina a cero para la siguiente llamada
    if(!posicion)
        cadena.resize(0);
}
 

Alternativa:

/*
 *  linea de comandos:
 *      nombreprograma alfabeto longitud
 */
 
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
 
using namespace std;
 
unsigned long convertir(char *s);
void bruteforce(char *alfabeto,unsigned long longitud);
 
int main(int argc, char *argv[])
{
    unsigned long l;
 
    if(argc != 3)
    {
        cerr << argv[0] << " alfabeto longitud" << endl;
        return -1;
    }
 
    if(!(l = strlen(argv[1])))
    {
        cerr << argv[0] << " alfabeto longitud" << endl;
        return -1;
    }
 
 
    //eliminamos caracteres repetidos del alfabeto
    for(int i = 0 ; i < strlen(argv[1]) ; i++)
        if(strchr(argv[1] + i + 1 , argv[1][i]))
        {
            memmove(argv[1] + i ,argv[1] + i  + 1, (l--) - i );
            i--;
        }
 
    //nos aseguramos de que el segundo argumento sea numerico
    for(int i = 0 ; argv[2][i] ; i++)
        if(argv[2][i] < '0' || argv[2][i] > '9')
        {
            cerr << argv[0] << " alfabeto longitud" << endl;
            return -1;
        }
 
    bruteforce(argv[1],convertir(argv[2]));
 
    return 0;
}
 
unsigned long convertir(char *s)
{
    unsigned long ret = 0;
 
    for(int i = 0 ; s[i] ; i++)
    {
        ret *= 10;
        ret += s[i] - '0';
    }
 
    return ret;
}
 
void bruteforce(char *alfabeto,unsigned long longitud)
{
    static string cadena;
    static unsigned long posicion = 0;
 
    if(posicion == longitud)
    {
        //si hemos llegado a la ultima posicion almacenamos la variacion
        cout << (cadena) << endl;
        return;
    }
 
    //si es la primera llamada damos la longitud deseada a la cadena
    if(posicion == 0)
        cadena.resize(longitud);
 
    //para cada una de los caracteres del alfabeto
    for(int i = 0 ; alfabeto[i] ; i++)
    {
        cadena[posicion] = alfabeto[i]; //asignamos a la posicion correspondiente el caracter del alfabeto.
 
        //avanzamos una posicion
        posicion++;
 
        //y calculamos el siguiente caracter
        bruteforce(alfabeto , longitud);
 
        //volvemos a la posicion original
        posicion--;
    }
 
    //posicion termina a cero para la siguiente llamada
    if(!posicion)
        cadena.resize(0);
}
 

do-while el 2 no compila

a.cpp:14: ANSI C++ forbids implicit conversion from `void *' in assignment

el otro te subo los puntos

quien haga otro programa más rápido que el de el ganara más puntos
o si alguien lo hace más lento ganaras mas puntos tu do-while

¡Buenas!

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
    FILE *f;
    char *contenido;
    unsigned long longitud;
 
    f=fopen("algunfichero","rb");
 
    fseek(f,0,SEEK_END);
 
    if(!(contenido = (char*) malloc(longitud = ftell(f))))
        return -1;
 
    fseek(f,0,SEEK_SET);
 
    fread(contenido,longitud,1,f);
 
    fclose(f);
 
    free(contenido);
 
    return 0;
}
 

Prueba ahora, que en C++ me parece que no se puede asignar un punter void a un puntero no void. Obliga a hacer el cast.

¡Saludos!

ami no me salta ningun error pero no me habre ningun archivo ya probe de crear un archivo con ese nombre y camiar el nombre pero no muestra el texto del documento

El programa de do-while que es el crackeador de md5 o el generador de diccionarios? Lo digo porque ya he solucionado lo de que no escribiera en el mio.

Es simple, pero se puede hacer mas complejo.

#include <stdio.h>
 
int main()
{
char vars[6];
vars[5]='\n';
FILE* diccionario = fopen("diccionario", "w");
for(vars[0]='a'; vars[0]<'z'; vars[0]++)
 {
   for(vars[1]='a'; vars[1]<'z'; vars[1]++)
   {
     for(vars[2]='a'; vars[2]<'z'; vars[2]++)
      {
        for(vars[3]='a';vars[3]<'z'; vars[3]++)
         {
 
          for(vars[4]='a';vars[4]<'z'; vars[4]++)
           {fprintf(diccionario, "%s", vars);}
         }
      }
   }
 }
fclose(diccionario);
return 0;
}
 

Es C, ahora lo subo en C++.

el suyo es el de fuerza bruta de momento dowhile va ganando haber si lo superas

¡Buenas!

¿A que te refieres con un crackeador de MD5? ¿A redibir como argumento un hash y generar una cadena que de el mismo hash?

Ok, pero yo gano puntos o no? Se me ha adelantado por segundos :-[

Aqui esta en C++:

#include <fstream>
 
int main()
{
char vars[6];
vars[5]='\n';
ofstream diccionario.open("diccionario", ios::out);
for(vars[0]='a'; vars[0]<'z'; vars[0]++)
 {
   for(vars[1]='a'; vars[1]<'z'; vars[1]++)
   {
     for(vars[2]='a'; vars[2]<'z'; vars[2]++)
      {
        for(vars[3]='a';vars[3]<'z'; vars[3]++)
         {
 
          for(vars[4]='a';vars[4]<'z'; vars[4]++)
           {diccionario.write(vars, 6);}
         }
      }
   }
 }
diccionario.close();
return 0;
}

si

EI: juntando mensajes.


el a echo el 4 tambien

ahora lo k podeis hacer es competir para que vuestro porgrama sea más rapido  por ejemplo haciendo k el script en vez de imprimir por pantalla lo guarde en un fichero y el que lo haga más rapido gana 10 puntos +

EI: juntando mensajes.

0xdani

a.cpp: In function `int main()':
a.cpp:7: parse error before `.'

#include <fstream>
 
using namespace std;
 
int main()
{
char vars[6];
vars[5]='\n';
ofstream diccionario;
diccionario.open("diccionario", ios::out);
for(vars[0]='a'; vars[0]<'z'; vars[0]++)
 {
   for(vars[1]='a'; vars[1]<'z'; vars[1]++)
   {
     for(vars[2]='a'; vars[2]<'z'; vars[2]++)
      {
        for(vars[3]='a';vars[3]<'z'; vars[3]++)
         {
 
          for(vars[4]='a';vars[4]<'z'; vars[4]++)
           {diccionario.write(vars, 6);}
         }
      }
   }
 }
diccionario.close();
return 0;
}
 

EI: juntando mensajes.

Alguien puede probar esto? No se si las librerias crypt.h y unistd.h funcionan en windows, pero para compilar: gcc md5.c -o md5 -lcrypt.

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <crypt.h>
 
int main(int argc, char* argv[])
{
    const char salt[] = "$1$........";
    char *buf, pass[30];
    FILE* file = fopen(argv[1], "r");
    printf("Escribe el hash: ");
    fgets(pass, 30, stdin);
    while(!feof(file))
    {
     fgets(buf, 30, file);
     buf = crypt(buf, salt);
     if(!strcmp(pass, buf)) break;
    }
    printf("Password: %s", buf);
    fclose(file);
    getchar();
    return 0;
}

Le tienes que pasar un diccionario como argumento, y escribir el hash.

Saludos.

no tnego el crypt.h por lo que no compila despues lo busco

el que haga el script de generar el diccionario mas rapido gana 10p

8.

El crackeador de MD5. Compilado utilizando g++ funciona (probad con cadenas cortas y con minusculas). Supongo que podria fallar con otros compiladores o versiones de g++ distintas de la que tengo, a fin de cuentas no deja de ser un popurri de unos cuantos codigos que tenia hechos anteriormente. Mi version de g++ considera unsigned long de 32 bits y unsigned long long de 64. Tampoco se si funcionara en todos los casos, lo que si puedo asegurar es que con cadenas cortas y de minusculas funciona...

/*
 * Linea de comandos:
 *      nombreprograma hash
 * Salida: Cadena cuyo hash MD5 es el que se ha recibido
 *
 *
 * Dada una cadena MD5 devuelve una cadena de digitos hexadecimales de 32 bytes
 *
 *
 * Considerando como conjunto de salida las cadenas de digitos hexadecimales de 32 bytes,
 * MD5 sera por lo tanto suprayectiva y tendra que existir al menos una cadena de 32 bytes
 * hexadecimales cuya imagen sea el valor que recibimos como parametro.
 *
 */
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
 
using namespace std;
 
#ifndef ULL_MAX
    #define ULL_MAX 0xFFFFFFFFFFFFFFFFULL
#endif
/*
 *
 * Calcula el MD5 del input y devuelve una cadena dinamica que lo contiene.
 *
 */
 
char* md5(char *input, unsigned long  long len);
 
/* Ajusta la cadena a una longitud multiplo de 512 - 64 bits y añade la longitud en 64 bits */
unsigned long long md5_ajustar_datos(char **datos, unsigned long  long len);
 
unsigned long md5_extraer_submensaje(char *m , unsigned long sub , unsigned long bloque);
 
unsigned long md5FF(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5GG(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5HH(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
unsigned long md5II(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t);
 
#define MD5_LONGITUD 32
 
#define md5_extraer_submensaje(m , sub , bloque) (((unsigned long*)(m))[(bloque) * 16 + (sub)])
 
#define md5F(X,Y,Z)(((X) & (Y)) | ((~(X)) & (Z)))
#define md5G(X,Y,Z)(((X) & (Z)) | ((Y) & (~(Z))))
#define md5H(X,Y,Z)((X) ^ (Y) ^ (Z))
#define md5I(X,Y,Z)((Y) ^ ((X) | (~(Z))))
 
char* md5(char *input, unsigned long long len)
{
    unsigned long reg[4], aux_reg[4], bloque = 0, i, j;
    unsigned long long longitud;
    char *aux;
 
    if(!(aux = (char*) malloc(len * sizeof(char))))
        return NULL;
 
    memmove(aux , input , len * sizeof(char));
 
    if(!(longitud = md5_ajustar_datos(&aux , len)))
    {
        free(aux);
        return NULL;
    }
 
    reg[0] = 0x67452301UL;
    reg[1] = 0xEFCDAB89UL;
    reg[2] = 0x98BADCFEUL;
    reg[3] = 0x10325476UL;
 
    /* mientras haya bloques de 64 bytes (512 bits) */
    while(longitud)
    {
        for(i = 0 ; i < 4 ; i++)
            aux_reg[i] = reg[i];
 
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,0,bloque) ,7LU ,3614090360LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,1,bloque) ,12LU ,3905402710LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,2,bloque) ,17LU ,606105819LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,3,bloque) ,22LU ,3250441966LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,4,bloque) ,7LU ,4118548399LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,5,bloque) ,12LU ,1200080426LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,6,bloque) ,17LU ,2821735955LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,7,bloque) ,22LU ,4249261313LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,8,bloque) ,7LU ,1770035416LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,9,bloque) ,12LU ,2336552879LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,10,bloque) ,17LU ,4294925233LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,11,bloque) ,22LU ,2304563134LU);
        md5FF( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,12,bloque) ,7LU ,1804603682LU);
        md5FF( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,13,bloque) ,12LU ,4254626195LU);
        md5FF( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,14,bloque) ,17LU ,2792965006LU);
        md5FF( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,15,bloque) ,22LU ,1236535329LU);
 
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,1,bloque) ,5LU ,4129170786LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,6,bloque) ,9LU ,3225465664LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,11,bloque) ,14LU ,643717713LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,0,bloque) ,20LU ,3921069994LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,5,bloque) ,5LU ,3593408605LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,10,bloque) ,9LU ,38016083LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,15,bloque) ,14LU ,3634488961LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,4,bloque) ,20LU ,3889429448LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,9,bloque) ,5LU ,568446438LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,14,bloque) ,9LU ,3275163606LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,3,bloque) ,14LU ,4107603335LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,8,bloque) ,20LU ,1163531501LU);
        md5GG( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,13,bloque) ,5LU ,2850285829LU);
        md5GG( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,2,bloque) ,9LU ,4243563512LU);
        md5GG( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,7,bloque) ,14LU ,1735328473LU);
        md5GG( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,12,bloque) ,20LU ,2368359562LU);
 
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,5,bloque) ,4LU ,4294588738LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,8,bloque) ,11LU ,2272392833LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,11,bloque) ,16LU ,1839030562LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,14,bloque) ,23LU ,4259657740LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,1,bloque) ,4LU ,2763975236LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,4,bloque) ,11LU ,1272893353LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,7,bloque) ,16LU ,4139469664LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,10,bloque) ,23LU ,3200236656LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,13,bloque) ,4LU ,681279174LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,0,bloque) ,11LU ,3936430074LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,3,bloque) ,16LU ,3572445317LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,6,bloque) ,23LU ,76029189LU);
        md5HH( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,9,bloque) ,4LU ,3654602809LU);
        md5HH( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,12,bloque) ,11LU ,3873151461LU);
        md5HH( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,15,bloque) ,16LU ,530742520LU);
        md5HH( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,2,bloque) ,23LU ,3299628645LU);
 
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,0,bloque) ,6LU ,4096336452LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,7,bloque) ,10LU ,1126891415LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,14,bloque) ,15LU ,2878612391LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,5,bloque) ,21LU ,4237533241LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,12,bloque) ,6LU ,1700485571LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,3,bloque) ,10LU ,2399980690LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,10,bloque) ,15LU ,4293915773LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,1,bloque) ,21LU ,2240044497LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,8,bloque) ,6LU ,1873313359LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,15,bloque) ,10LU ,4264355552LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,6,bloque) ,15LU ,2734768916LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,13,bloque) ,21LU ,1309151649LU);
        md5II( &aux_reg[0], aux_reg[1], aux_reg[2], aux_reg[3], md5_extraer_submensaje(aux,4,bloque) ,6LU ,4149444226LU);
        md5II( &aux_reg[3], aux_reg[0], aux_reg[1], aux_reg[2], md5_extraer_submensaje(aux,11,bloque) ,10LU ,3174756917LU);
        md5II( &aux_reg[2], aux_reg[3], aux_reg[0], aux_reg[1], md5_extraer_submensaje(aux,2,bloque) ,15LU ,718787259LU);
        md5II( &aux_reg[1], aux_reg[2], aux_reg[3], aux_reg[0], md5_extraer_submensaje(aux,9,bloque) ,21LU ,3951481745LU);
 
 
        for(i = 0 ; i < 4 ; i++)
            reg[i] += aux_reg[i];
 
        bloque++;
        longitud -= 64; /* descontamos un bloque de 64 bytes, 512 bits */
    }
 
    free(aux);
 
    if(!(aux = (char*) malloc(33 * sizeof(char))))
        return NULL;
 
    aux[0] = '\0';
 
    for(i = 0 ; i < 4 ; i++)
        for(j = 0 ; j < 4 ; j++)
            sprintf(aux,"%s%02X",aux,(unsigned char)((char*)&(reg[i]))[j]);
 
    return aux;
}
 
unsigned long long md5_ajustar_datos(char **datos, unsigned long long len)
{
    unsigned long long new_len;
    char *aux;
    int c = 0;
 
    /* si longitud en bits es mayor que ULL_MAX */
    if(len > ULL_MAX / 8)
        return 0; /* devolvemos falso */
 
    if(64 - (len % 64) > 8)
    {
        if(ULL_MAX - (64 - (len % 64)) >= len)
            new_len = len + (64 - (len % 64));
        else
            return 0;
    }
    else
    {
        if(ULL_MAX - 64 - (64 - (len % 64)) >= len)
            new_len = len + 64 + (64 - (len % 64));
        else
            return 0;
    }
 
    if(!(aux = (char*) realloc(*datos , new_len * sizeof(char))))
        return 0;
 
    (*datos) = aux;
 
    c = 1 << 7;
 
    memset((*datos) + len , c , sizeof(char));
    memset((*datos) + len + 1 , 0 , (new_len - len - 1) * sizeof(char));
 
    /* pasamos la longitud de bytes a bits */
    len *= 8;
 
    memcpy((*datos) + new_len - 8 , &len , 8 * sizeof(char));
 
    return new_len;
}
 
unsigned long md5FF(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5F(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
unsigned long md5GG(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5G(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
unsigned long md5HH(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5H(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
unsigned long md5II(unsigned long *a,unsigned long b,unsigned long c,unsigned long d,unsigned long m,unsigned long s,unsigned long t)
{
    unsigned long aux;
 
    aux = (*a + md5I(b, c, d) + m + t);
 
    *a = b + ((aux << s) | (aux >> (32 - s)));
 
    return *a;
}
 
 
int MD5_bruteforce(string MD5,unsigned long longitud)
{
    static string cadena;
    static unsigned long posicion = 0;
    static char* alfabeto = "abcdefghijklmnopqrstuvwxyz"; //con este alfabeto abarcamos el espacio imagen en menos iteraciones
 
    if(posicion == longitud)
    {
        //si hemos llegado a la ultima posicion almacenamos la variacion
        if(string(md5((char*)cadena.c_str(), cadena.length())) == MD5)
        {
            cout << cadena;
            return 1;
        }
 
        return 0;
    }
 
    //si es la primera llamada damos la longitud deseada a la cadena
    if(posicion == 0)
        cadena.resize(longitud);
 
    //para cada uno de los caracteres del alfabeto
    for(int i = 0 ; alfabeto[i] ; i++)
    {
        cadena[posicion] = alfabeto[i]; //asignamos a la posicion correspondiente el caracter del alfabeto.
 
        //avanzamos una posicion
        posicion++;
 
        //y calculamos el siguiente caracter
        if(MD5_bruteforce(MD5,longitud))
        {
            posicion = 0;
            cadena.resize(0);
            return 1;
        }
 
        //volvemos a la posicion original
        posicion--;
    }
 
    //posicion termina a cero para la siguiente llamada
    if(!posicion)
        cadena.resize(0);
 
    return 0;
}
 
int main(int argc, char *argv[])
{
    string MD5;
 
    if(argc != 2)
    {
        cout << argv[0] << " MD5_hash" << endl;
        return -1;
    }
 
    if(strlen(argv[1]) != 32)
    {
        cout << argv[0] << " MD5_hash" << endl;
        return -1;
    }
 
    for(int i = 0 ; i < 32 ; i++)
    {
        argv[1][i] = toupper(argv[1][i]);
 
        if(!((argv[1][i] >= '0' && argv[1][i] <= '9') || (argv[1][i]>= 'A' && argv[1][i]<='Z')))
        {
            cout << argv[0] << " MD5_hash" << endl;
            return -1;
        }
    }
 
    MD5 = argv[1];
 
 
    if(string(md5("",0)) != MD5)
    {
        for(int i = 1 ; i < 32 ; i++)
            if(MD5_bruteforce(MD5,i))
                break;
    }
    else
        cout <<"Cadena vacia" << endl;
 
    return 0;
}