Si! LO he conseguido, he hecho que el algoritmo sea dinámico y ampliable, he empezado a trabajar de nuevo en el para un projecto que requiere una comunicación de red, para realizar checksums, y modificar otros por fuerza bruta.

Tal como esta el codigo puesto (podeis modificar 2 parametros para ampliarlo), puede descifrar cualquier cadena de texto de 3 caracteres que contenga A,B,C por lo que yo he usado como ejemplo el siguiente hash:
 md5("ACB") = 79661ff25e39af70fc48d7785f587e85;

Vamos a cualquier pagina de cifrado MD5 y le metemos el siguiente texto para cifrar:
ACB y obtenemos que la hash es: 79661ff25e39af70fc48d7785f587e85

Si no sabemos como devolverla al estado original ahora viene cuando actua mi programa:

import java.lang.String;
import java.math.BigInteger;
import java.security.MessageDigest;root
import java.security.NoSuchAlgorithmException;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 *
 * @author Debci
 */
public class Encriptor {
 
 
    public static void main(String[] args)
    {
        String resultado = null;
        String match = "79661ff25e39af70fc48d7785f587e85";
 
 
        char[] mapaChars = {'A','B','C','D'};
        int longitud = 3;
        int posibles = (int) Math.pow(longitud,mapaChars.length);
 
        char[] combinacion = new char[longitud];
 
        int[] indice = new int[longitud];
        for(int i = 0; i < posibles;i++)
        {
          for(int x = 0; x < indice.length; x++) {
           if(!(x==indice.length)) {
                  if(indice[x] == mapaChars.length) {
                    indice[x] = 0;
                    indice[x+1]++;
                  }
                }else{
                  indice[x] = 0;
                }
          }
 
          for(int h = 0; h < longitud; h++) {
              combinacion[h] = mapaChars[indice[h]];
          }
 
          char[] resultadoTemporal = new char[longitud];
          for(int j = 0; j < combinacion.length; j++) {
              resultadoTemporal[j] = combinacion[j];
          }
          //System.out.println(resultadoTemporal);
          String resultadoFinal = new String(resultadoTemporal);
          String resultadoEncriptado = new String(Encriptor.encriptaMD5(resultadoFinal));
          if(resultadoEncriptado.equals(match))
          {
              resultado = resultadoTemporal.toString();
              System.out.println("Hash crackeada con exito!\n" + resultadoFinal);
              break;
          }
 

Encriptad cualquier cadena con los caracteres:

char[] mapaChars = {'A','B','C','D'};

Añadid los que querais, para crackear cualquier hash, el algoritmo esta diseñado para adaptarse a un nuevo dicionario y a la longitud de la hash variable:

int longitud = 3;

Osea que es extensible, pero si aumentamos mucho puede no funcionar por limitaciones de datos tipo int, las posibilidades serian grandiosas y un int no puede con un dato asi de grande, por lo que ya trabajo en un método para no depender de la VM de java y almacenar dicho numero de combinaciones posibles en memoria directamente.
Cabe mencionar que para entender el codigo quizás haya que tener un nivel medio-basico de combinatoria y matematicas estadisticas (sobre todo con probabilidad).

Disfruten el codigo!

Leyer estate tranquilo que esta quedando de coña!

Saludos

Versión mejorada:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
package funcional;
 
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 *
 * @author debci
 */
public class Generador {
    private char[] mapaChars;
    private boolean acabado = false;
private Generador(int ArgCount, char[] ArgAlpha) {
    mapaChars = ArgAlpha;
}
public static void main(String[] args) {
    Generador generador = new Generador();
    generador.getAllCombo();
}
 
private Generador() {
 
}
public void getAllCombo() {
        String resultado = null;
        String match = "79661ff25e39af70fc48d7785f587e89";
 
 
        char[] mapaChars = {'A','B','C','D','E','F','\0'};
        int longitud = 7;
        BigInteger largo = BigInteger.valueOf(mapaChars.length);
 
 
        BigInteger posibles = largo.pow(longitud);
        System.out.println("[!]Hay " + posibles + " combinaciones posibles.");
 
        char[] combinacion = new char[longitud];
 
        int[] indice = new int[longitud];
        while(!acabado)
        {
          try{
          for(int x = 0; x < indice.length; x++) {
           if(!(x==(indice.length))) {
                  if((indice[x] == (mapaChars.length))) {
                    indice[x] = 0;
                    indice[x+1]++;
                  }
                }else{
                  indice[x] = 0;
                }
          }
 
          for(int h = 0; h < longitud; h++) {
              combinacion[h] = mapaChars[indice[h]];
          }
 
          char[] resultadoTemporal = new char[longitud];
          for(int j = 0; j < combinacion.length; j++) {
              resultadoTemporal[j] = combinacion[j];
          }
 
          String resultadoFinal = new String(resultadoTemporal);
          String resultadoEncriptado = new String(this.encriptaMD5(resultadoFinal));
          System.out.println(resultadoFinal + " =======> " + resultadoEncriptado);
 
          if(resultadoEncriptado.equals(match))
          {
              resultado = resultadoTemporal.toString();
              System.out.println("Hash crackeada con exito!\n" + resultadoFinal);
              break;
          }
 
          indice[0]++;
          //System.out.println("[!]Quedan " + posibles + " combinaciones.");
 
          if(posibles.equals(BigInteger.ONE)) {
              acabado = true;
          }
 
            posibles = posibles.subtract(BigInteger.ONE);
 
        }catch(ArrayIndexOutOfBoundsException e){
 
        }
    }
    }
public static String encriptaMD5(String toEnc)
    {
 
 
        MessageDigest mdEnc = null;
        try {
            mdEnc = MessageDigest.getInstance("MD5"); // Encryption algorithm
        } catch (NoSuchAlgorithmException ex) {
            System.err.println("No se ha encontrado el algoritmo.");
        }
 
            mdEnc.update(toEnc.getBytes(), 0, toEnc.length());
 
            String md5 = new BigInteger(1, mdEnc.digest()).toString(16);
            return md5;
    }
}

Ahora ya no tiene limite, puedes añadir cuanta longitud te plazca y todos los caracteres al aphabeto que quieras.


Saludos

Asi de ser pesado, solo para molestar pero también dejando una propuesta para mejorar el conocimiento.

Me gustaria saber mucho de que complejidad son los algoritmos  presentados aqui en función del largo de la cadena que se desea obtener por ejemplo.
Esto es util ya que si quiero desencryptar un MD5 cuanto tiempo me tomara a priori sin a ejecutar tal algoritmo.

Espero que me respondan.

Saludos 

Para no hacerlo cada vez no sería mejor guardar todo en una base de datos?
 
Por ejemplo "palabra" y "md5" asi luego  sólo se compara el md5 ingresado y se muestra la palabra a la que corresponda. En este caso la fuerza bruta no es muy óptima.
 
Por lo demás sería bueno que se consideren números y letras xD sin contar mayúsculas y minúsculas que enmonstruesen mas aún esto...
 
La base de datos sería inmensa pero sería trabajo de sólo una vez, lo mismo que la espera.