Mensajes

No puedes incluir de esa manera librerias no adaptadas a la interfaz nativa, te recomiendo que busques un homólogo para java.

Saludos

Que yo sepa no puedes poisonear arp de un servidor remoto al cual no tienes contacto si quiera en Lan... 
Al menos que yo sepa...

Saludos

Donde conseguiste exactamente esos valores?
Es parte de un trabajo de Cómputo?
Si te digo la verdad estas cosas solo las habia hecho con C pero si me dices donde hay una lista con los tiempos o una documentación al respecto, prometo ayudarte en lo que me sea posible.

Saludos

Sencillamente que esa maquina no es vulnerable, acostumbrate a leer los errores que devuelve porque son bastante explícitos y te ayudarán en ocasiones futuras a determinar el fallo del pentest.

Saludos

Tu mismo puedes observar que dice que LHOST es un parámetro requerido y esta vacío.

Saludos

Claro que si, pero primero debo conseguir un hd de por lo menos 1 Tb (como minimo) y luego hacerlo para que saque todas las hashes desde un solo digito(longitud de la cadena 1) hasta por ejemplo 15 digitos.

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  

Pues dependeria mucho de tu ordenador, y del algoritmo en si, además este es inutil si no conoces la longitud de la cadena pasada a hash.
EDITO:
Añadida mejora multifuncional:
Ahora si selecionamos una cadena de 16 caracteres, comprobara los de 1, 2 ,3 ,4 ,5... no solamente generara cadenas de 16, por loq ue ahora crackea todo tipo de hashes con un límitem establecido.

Código (java) [Seleccionar] Expandir

/*
* 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',' '};
        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;
                }
          }
          //Asignamos la combinación numérica al vector de caracteres
          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 cadenaFormateada = new String();
          /* Formateamos la cadena quitandole los espacios existentes para */
          /* generar todas las formas posibles                             */
          for (int x = 0; x < resultadoFinal.length(); x++) {
               if (resultadoFinal.charAt(x) != ' ') {
                 cadenaFormateada += resultadoFinal.charAt(x);
              }
          }
          String resultadoEncriptado = new String(this.encriptaMD5(cadenaFormateada));
          System.out.println(cadenaFormateada + " =======> " + 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 crackea con un limite, osea si le dices 16 caracteres de limite, prueba con todas las longitudes anteriores, usando el ingenio lo que he hecho ha sido añadir el caracter ' ' al dicionario y luego parsear las cadenas para que lo elimine creando asi todo tipo de cadenas.

Saludos
Saludos

Versión mejorada:

Código (java) [Seleccionar] Expandir

/*
* 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

Que listo que es nuestro querido Basic xDDD

Saludos

Podrias buscar que otras paginas los incluyen en el source para usar esa input...

Saludos

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:

Código (java) [Seleccionar] Expandir


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:

Código (java) [Seleccionar] Expandir

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:

Código (java) [Seleccionar] Expandir

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