¿Cómo puedo generar un hash MD5?

¿Hay algún método para generar el hash MD5 de una cadena en Java?

Es necesario java.security.MessageDigest.

Llame MessageDigest.getInstance("MD5")para obtener una instancia de MD5 MessageDigestque pueda usar.

Calcule el hash haciendo uno de:

• Alimente toda la entrada como a byte[]y calcule el hash en una operación con md.digest(bytes).
• Alimenta MessageDigestun byte[]trozo a la vez llamando md.update(bytes). Cuando termine de agregar bytes de entrada, calcule el hash con md.digest().

El byte[]devuelto por md.digest()es el hash MD5.

La MessageDigestclase puede proporcionarle una instancia del resumen MD5.

Cuando trabaje con cadenas y las clases de cifrado, asegúrese de especificar siempre la codificación en la que desea la representación de bytes. Si solo la usa string.getBytes(), usará la plataforma predeterminada. (No todas las plataformas usan los mismos valores predeterminados)

import java.security.*;

..

byte[] bytesOfMessage = yourString.getBytes("UTF-8");

MessageDigest md = MessageDigest.getInstance("MD5");
byte[] thedigest = md.digest(bytesOfMessage);

Si tiene muchos datos, eche un vistazo al .update(byte[])método al que se puede llamar repetidamente. Luego llame .digest()para obtener el hash resultante.

Si realmente desea que la respuesta se devuelva como una cadena en lugar de una matriz de bytes, siempre puede hacer algo como esto:

String plaintext = "your text here";
MessageDigest m = MessageDigest.getInstance("MD5");
m.reset();
m.update(plaintext.getBytes());
byte[] digest = m.digest();
BigInteger bigInt = new BigInteger(1,digest);
String hashtext = bigInt.toString(16);
// Now we need to zero pad it if you actually want the full 32 chars.
while(hashtext.length() < 32 ){
  hashtext = "0"+hashtext;
}

También es posible que desee ver la clase DigestUtils del proyecto de códec apache commons , que proporciona métodos muy convenientes para crear resúmenes MD5 o SHA.

Encontró esto:

public String MD5(String md5) {
   try {
        java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
        byte[] array = md.digest(md5.getBytes());
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < array.length; ++i) {
          sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
       }
        return sb.toString();
    } catch (java.security.NoSuchAlgorithmException e) {
    }
    return null;
}

en el sitio a continuación, no me lo atribuyo, ¡pero es una solución que funciona! Para mí, muchos otros códigos no funcionaron correctamente, terminé perdiendo ceros en el hash. Este parece ser el mismo que PHP tiene. fuente: http://m2tec.be/blog/2010/02/03/java-md5-hex-0093

Así es como lo uso:

final MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.reset();
messageDigest.update(string.getBytes(Charset.forName("UTF8")));
final byte[] resultByte = messageDigest.digest();
final String result = new String(Hex.encodeHex(resultByte));

donde está Hex: org.apache.commons.codec.binary.Hexdel proyecto Apache Commons .

Acabo de descargar commons-codec.jar y obtuve php perfecto como md5. Aquí está el manual .

Solo impórtalo a tu proyecto y úsalo

String Url = "your_url";

System.out.println( DigestUtils.md5Hex( Url ) );

Y ahí lo tienes.

He descubierto que esta es la forma más clara y concisa de hacerlo:

MessageDigest md5 = MessageDigest.getInstance("MD5");
md5.update(StandardCharsets.UTF_8.encode(string));
return String.format("%032x", new BigInteger(1, md5.digest()));

Encontré esta solución que es mucho más limpia en términos de recuperar una representación de cadena de un hash MD5.

import java.security.*;
import java.math.*;

public class MD5 {
    public static void main(String args[]) throws Exception{
        String s="This is a test";
        MessageDigest m=MessageDigest.getInstance("MD5");
        m.update(s.getBytes(),0,s.length());
        System.out.println("MD5: "+new BigInteger(1,m.digest()).toString(16));
    }
}

El código fue extraído de aquí .

Otra opción es utilizar los métodos Hashing de guayaba :

Hasher hasher = Hashing.md5().newHasher();
hasher.putString("my string");
byte[] md5 = hasher.hash().asBytes();

Práctico si ya está usando Guava (que si no lo está, probablemente debería estarlo).

Otra implementación:

import javax.xml.bind.DatatypeConverter;

String hash = DatatypeConverter.printHexBinary( 
           MessageDigest.getInstance("MD5").digest("SOMESTRING".getBytes("UTF-8")));

Tengo una clase (Hash) para convertir texto sin formato en hash en formatos: md5 o sha1, similar a las funciones de php ( md5 , sha1 ):

public class Hash {
    /**
     * 
     * @param txt, text in plain format
     * @param hashType MD5 OR SHA1
     * @return hash in hashType 
     */
    public static String getHash(String txt, String hashType) {
        try {
                    java.security.MessageDigest md = java.security.MessageDigest.getInstance(hashType);
                    byte[] array = md.digest(txt.getBytes());
                    StringBuffer sb = new StringBuffer();
                    for (int i = 0; i < array.length; ++i) {
                        sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
                 }
                    return sb.toString();
            } catch (java.security.NoSuchAlgorithmException e) {
                //error action
            }
            return null;
    }

    public static String md5(String txt) {
        return Hash.getHash(txt, "MD5");
    }

    public static String sha1(String txt) {
        return Hash.getHash(txt, "SHA1");
    }
}

Pruebas con JUnit y PHP

Script PHP:

<?php

echo 'MD5 :' . md5('Hello World') . "\n";
echo 'SHA1:' . sha1('Hello World') . "\n";

Script PHP de salida:

MD5 :b10a8db164e0754105b7a99be72e3fe5
SHA1:0a4d55a8d778e5022fab701977c5d840bbc486d0

Usando ejemplos y pruebas con JUnit:

    public class HashTest {

    @Test
    public void test() {
        String txt = "Hello World";
        assertEquals("b10a8db164e0754105b7a99be72e3fe5", Hash.md5(txt));
        assertEquals("0a4d55a8d778e5022fab701977c5d840bbc486d0", Hash.sha1(txt));
    }

}

Código en GitHub

https://github.com/fitorec/java-hashes

No hay necesidad de hacerlo demasiado complicado.
DigestUtils funciona bien y te hace sentir cómodo mientras trabajas con md5hashes.

DigestUtils.md5Hex(_hash);

o

DigestUtils.md5(_hash);

Puede utilizar cualquier otro método de cifrado como shao md.

Mi respuesta no muy reveladora:

private String md5(String s) {
    try {
        MessageDigest m = MessageDigest.getInstance("MD5");
        m.update(s.getBytes(), 0, s.length());
        BigInteger i = new BigInteger(1,m.digest());
        return String.format("%1$032x", i);         
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return null;
}

También hay una DigestUtilsclase en primavera :

http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/util/DigestUtils.html

Esta clase contiene el método md5DigestAsHex()que hace el trabajo.

Puedes intentar seguir. Vea los detalles y los códigos de descarga aquí: http://jkssweetlife.com/java-hashgenerator-md5-sha-1/

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Example {

public static void main(String[] args) throws Exception {

    final String inputString = "Hello MD5";

    System.out.println("MD5 hex for '" + inputString + "' :");
    System.out.println(getMD5Hex(inputString));
}

public static String getMD5Hex(final String inputString) throws NoSuchAlgorithmException {

    MessageDigest md = MessageDigest.getInstance("MD5");
    md.update(inputString.getBytes());

    byte[] digest = md.digest();

    return convertByteToHex(digest);
}

private static String convertByteToHex(byte[] byteData) {

    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < byteData.length; i++) {
        sb.append(Integer.toString((byteData[i] & 0xff) + 0x100, 16).substring(1));
    }

    return sb.toString();
}
}

La respuesta de Bombe es correcta, sin embargo, tenga en cuenta que, a menos que deba usar MD5 (por ejemplo, forzado para la interoperabilidad), una mejor opción es SHA1 ya que MD5 tiene debilidades para el uso a largo plazo.

Debo agregar que SHA1 también tiene vulnerabilidades teóricas, pero no tan graves. El estado actual de la técnica en hashing es que hay varias funciones de hash de reemplazo de candidatos, pero ninguna ha surgido como la mejor práctica estándar para reemplazar SHA1. Por lo tanto, dependiendo de sus necesidades, le recomendamos que configure su algoritmo hash para que pueda ser reemplazado en el futuro.

Otra implementación: Implementación rápida de MD5 en Java

String hash = MD5.asHex(MD5.getHash(new File(filename)));

No sé si esto es relevante para alguien que lea esto, pero acabo de tener el problema que quería

• descargar un archivo desde una URL dada y
• compare su MD5 con un valor conocido.

Quería hacerlo solo con las clases JRE (no Apache Commons o similar). Una búsqueda rápida en la web no me mostró fragmentos de código de muestra haciendo ambas cosas al mismo tiempo, solo cada tarea por separado. Debido a que esto requiere leer el mismo archivo dos veces, pensé que valdría la pena escribir un código que unifique ambas tareas, calculando la suma de verificación sobre la marcha mientras descarga el archivo. Este es mi resultado (perdón si no es Java perfecto, pero supongo que de todos modos tienes la idea):

import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.security.DigestOutputStream;        // new
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

void downloadFile(String fromURL, String toFile, BigInteger md5)
    throws IOException, NoSuchAlgorithmException
{
    ReadableByteChannel in = Channels.newChannel(new URL(fromURL).openStream());
    MessageDigest md5Digest = MessageDigest.getInstance("MD5");
    WritableByteChannel out = Channels.newChannel(
        //new FileOutputStream(toFile));  // old
        new DigestOutputStream(new FileOutputStream(toFile), md5Digest));  // new
    ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);  // 1 MB

    while (in.read(buffer) != -1) {
        buffer.flip();
        //md5Digest.update(buffer.asReadOnlyBuffer());  // old
        out.write(buffer);
        buffer.clear();
    }

    BigInteger md5Actual = new BigInteger(1, md5Digest.digest()); 
    if (! md5Actual.equals(md5))
        throw new RuntimeException(
            "MD5 mismatch for file " + toFile +
            ": expected " + md5.toString(16) +
            ", got " + md5Actual.toString(16)
        );
}

Eche un vistazo al siguiente enlace, el ejemplo obtiene un hash MD5 de una imagen suministrada: hash MD5 de una imagen

Por lo que vale, me topé con esto porque quiero sintetizar GUID a partir de una clave natural para un programa que instalará componentes COM; Quiero sintetizar para no administrar el ciclo de vida GUID. Usaré MD5 y luego usaré la clase UUID para obtener una cadena. (http://stackoverflow.com/questions/2190890/how-can-i-generate-guid-for-a-string-values/12867439 plantea este problema).

En cualquier caso, java.util.UUID puede obtener una buena cadena de los bytes MD5.

return UUID.nameUUIDFromBytes(md5Bytes).toString();

import java.security.*;
import javax.xml.bind.*;

byte[] bytesOfMessage = yourString.getBytes("UTF-8");
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] bytesOfDigest = md.digest(bytesOfMessage);
String digest = DatatypeConverter.printHexBinary(bytesOfDigest).toLowerCase();

A diferencia de PHP, donde puede hacer un hash MD5 de su texto simplemente llamando a la función md5, es decir md5($text), en Java se hizo un poco complicado. Por lo general, lo implementé llamando a una función que devuelve el texto hash md5. Así es como lo implementé, primero cree una función nombrada md5hashingdentro de su clase principal como se muestra a continuación.

public static String md5hashing(String text)
    {   String hashtext = null;
        try 
        {
            String plaintext = text;
            MessageDigest m = MessageDigest.getInstance("MD5");
            m.reset();
            m.update(plaintext.getBytes());
            byte[] digest = m.digest();
            BigInteger bigInt = new BigInteger(1,digest);
            hashtext = bigInt.toString(16);
            // Now we need to zero pad it if you actually want the full 32 chars.
            while(hashtext.length() < 32 ){
              hashtext = "0"+hashtext;   
            }
        } catch (Exception e1) 
        {
            // TODO: handle exception
            JOptionPane.showMessageDialog(null,e1.getClass().getName() + ": " + e1.getMessage());   
        }
        return hashtext;     
    }

Ahora llame a la función siempre que lo necesite como se indica a continuación.

String text = textFieldName.getText();
String pass = md5hashing(text);

Aquí puede ver que el hashtext se agrega con un cero para que coincida con el hash md5 en PHP.

MD5 está perfectamente bien si no necesita la mejor seguridad y si está haciendo algo como verificar la integridad del archivo, entonces la seguridad no es una consideración. En tal caso, es posible que desee considerar algo más simple y rápido, como Adler32, que también es compatible con las bibliotecas de Java.

este da el md5 exacto que obtienes de la función md5 de mysql o las funciones md5 de php, etc. Este es el que uso (puedes cambiar según tus necesidades)

public static String md5( String input ) {
    try {
        java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
        byte[] array = md.digest(input.getBytes( "UTF-8" ));
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < array.length; i++) {
            sb.append( String.format( "%02x", array[i]));
        }
        return sb.toString();
    } catch ( NoSuchAlgorithmException | UnsupportedEncodingException e) {
        return null;            
    }

}

prueba esto:

public static String getHashMD5(String string) {
    try {
        MessageDigest md = MessageDigest.getInstance("MD5");
        BigInteger bi = new BigInteger(1, md.digest(string.getBytes()));
        return bi.toString(16);
    } catch (NoSuchAlgorithmException ex) {
        Logger.getLogger(MD5Utils.class
                .getName()).log(Level.SEVERE, null, ex);

        return "";
    }
}

import java.security.MessageDigest

val digest = MessageDigest.getInstance("MD5")

//Quick MD5 of text
val text = "MD5 this text!"
val md5hash1 = digest.digest(text.getBytes).map("%02x".format(_)).mkString

//MD5 of text with updates
digest.update("MD5 ".getBytes())
digest.update("this ".getBytes())
digest.update("text!".getBytes())
val md5hash2 = digest.digest().map(0xFF & _).map("%02x".format(_)).mkString

//Output
println(md5hash1 + " should be the same as " + md5hash2)

Puede generar hash MD5 para un texto dado haciendo uso de los métodos de la MessageDigestclase en el java.securitypaquete. A continuación se muestra el fragmento de código completo,

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.xml.bind.DatatypeConverter;

public class MD5HashGenerator 
{

   public static void main(String args[]) throws NoSuchAlgorithmException
   {
       String stringToHash = "MyJavaCode"; 
       MessageDigest messageDigest = MessageDigest.getInstance("MD5");
       messageDigest.update(stringToHash.getBytes());
       byte[] digiest = messageDigest.digest();
       String hashedOutput = DatatypeConverter.printHexBinary(digiest);
       System.out.println(hashedOutput);
   }
}

La salida de la función MD5 es un hash de 128 bits representado por 32 números hexadecimales.

En el caso, si está utilizando una base de datos como MySQL, también puede hacerlo de una manera más simple. La consulta Select MD5(“text here”)devolverá el hash MD5 del texto en el paréntesis.

Esto es para lo que vine aquí: una práctica función de escala que devuelve una cadena de hash MD5:

def md5(text: String) : String = java.security.MessageDigest.getInstance("MD5").digest(text.getBytes()).map(0xFF & _).map { "%02x".format(_) }.foldLeft(""){_ + _}

 import java.math.BigInteger;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;

/**
* MD5 encryption
*
* @author Hongten
*
*/
public class MD5 {

 public static void main(String[] args) {
     System.out.println(MD5.getMD5("123456"));
 }

 /**
  * Use md5 encoded code value
  *
  * @param sInput
  * clearly
  * @ return md5 encrypted password
  */
 public static String getMD5(String sInput) {

     String algorithm = "";
     if (sInput == null) {
         return "null";
     }
     try {
         algorithm = System.getProperty("MD5.algorithm", "MD5");
     } catch (SecurityException se) {
     }
     MessageDigest md = null;
     try {
         md = MessageDigest.getInstance(algorithm);
     } catch (NoSuchAlgorithmException e) {
         e.printStackTrace();
     }
     byte buffer[] = sInput.getBytes();

     for (int count = 0; count < sInput.length(); count++) {
         md.update(buffer, 0, count);
     }
     byte bDigest[] = md.digest();
     BigInteger bi = new BigInteger(bDigest);
     return (bi.toString(16));
 }
}

Hay un artículo en Codingkit sobre eso. Echa un vistazo: http://codingkit.com/a/JAVA/2013/1020/2216.html