Como posso gerar um hash MD5?

Existe algum método para gerar o hash MD5 de uma string em Java?

Você precisa java.security.MessageDigest.

Ligue MessageDigest.getInstance("MD5")para obter uma instância MD5 que MessageDigestvocê possa usar.

Para calcular o hash, siga um destes procedimentos:

• Alimente toda a entrada como a byte[]e calcule o hash em uma operação com md.digest(bytes).
• Alimente MessageDigestum byte[]pedaço de cada vez ligando md.update(bytes). Quando você terminar de adicionar bytes de entrada, calcule o hash com md.digest().

O byte[]retornado por md.digest()é o hash MD5.

A MessageDigestclasse pode fornecer uma instância do resumo MD5.

Ao trabalhar com strings e as classes de criptografia, sempre especifique a codificação na qual você deseja a representação de bytes. Se você apenas a usar string.getBytes(), usará o padrão da plataforma. (Nem todas as plataformas usam os mesmos padrões)

import java.security.*;

..

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

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

Se você possui muitos dados, consulte o .update(byte[])método que pode ser chamado repetidamente. Em seguida, chame .digest()para obter o hash resultante.

Se você realmente deseja a resposta de volta como uma string, em vez de uma matriz de bytes, sempre pode fazer algo assim:

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;
}

Você também pode examinar a classe DigestUtils do projeto de codec do apache commons , que fornece métodos muito convenientes para criar resumos MD5 ou SHA.

Encontrou isto:

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;
}

no site abaixo, não aceito crédito, mas é uma solução que funciona! Para mim, muitos outros códigos não funcionaram corretamente, acabei perdendo 0s no hash. Este parece ser o mesmo que o PHP. fonte: http://m2tec.be/blog/2010/02/03/java-md5-hex-0093

Aqui está como eu o 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));

onde Hex é: org.apache.commons.codec.binary.Hexdo projeto Apache Commons .

Acabei de baixar commons-codec.jar e obtive um php perfeito como o md5. Aqui está o manual .

Basta importá-lo para o seu projeto e usar

String Url = "your_url";

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

e aí está.

Eu descobri que essa é a maneira mais clara e concisa de fazer isso:

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

Encontrei esta solução que é muito mais limpa em termos de recuperar uma representação de String de um 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));
    }
}

O código foi extraído daqui .

Outra opção é usar os métodos de Hashing de goiaba :

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

Prático, se você já estiver usando o Guava (que, se não estiver, provavelmente deveria).

Outra implementação:

import javax.xml.bind.DatatypeConverter;

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

Eu tenho uma classe (Hash) para converter texto sem formatação em hash em formatos: md5 ou sha1, simillar que funções 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");
    }
}

Testando com JUnit e PHP

Script PHP:

<?php

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

Script PHP de saída:

MD5 :b10a8db164e0754105b7a99be72e3fe5
SHA1:0a4d55a8d778e5022fab701977c5d840bbc486d0

Usando exemplo e Testando com JUnit:

    public class HashTest {

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

}

Código no GitHub

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

Não há necessidade de torná-lo muito complicado.
O DigestUtils funciona bem e deixa você confortável enquanto trabalha com md5hashes.

DigestUtils.md5Hex(_hash);

ou

DigestUtils.md5(_hash);

Você pode usar outros métodos de criptografia, como shaou md.

Minha resposta não muito 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;
}

Também há uma DigestUtilsclasse na primavera :

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

Esta classe contém o método md5DigestAsHex()que faz o trabalho.

Você pode tentar seguir. Veja detalhes e códigos de download aqui: 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();
}
}

A resposta de Bombe está correta, no entanto, observe que, a menos que você precise absolutamente usar o MD5 (por exemplo, forçado a interoperabilidade), uma melhor opção é SHA1, pois o MD5 tem pontos fracos para uso a longo prazo.

Devo acrescentar que o SHA1 também tem vulnerabilidades teóricas, mas não tão graves. O estado da arte atual no hash é que existem várias funções de hash de substituição de candidatos, mas nenhuma ainda surgiu como a melhor prática padrão para substituir o SHA1. Portanto, dependendo de suas necessidades, é recomendável que você configure seu algoritmo de hash para que possa ser substituído no futuro.

Outra implementação: Implementação rápida do MD5 em Java

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

Não sei se isso é relevante para quem está lendo isso, mas só tive o problema que queria

• baixar um arquivo de um determinado URL e
• compare seu MD5 com um valor conhecido.

Eu queria fazer isso apenas com classes JRE (sem Apache Commons ou similar). Uma pesquisa rápida na Web não me mostrou exemplos de trechos de código duas ao mesmo tempo, apenas cada tarefa separadamente. Como isso requer a leitura do mesmo arquivo duas vezes, achei que poderia valer a pena escrever algum código que unifique as duas tarefas, calculando a soma de verificação em tempo real durante o download do arquivo. Este é o meu resultado (desculpe se não é Java perfeito, mas acho que você entendeu a ideia):

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)
        );
}

Dê uma olhada no link a seguir, o Exemplo obtém um Hash MD5 de uma imagem fornecida: Hash MD5 de uma imagem

Pelo que vale, me deparei com isso porque quero sintetizar GUIDs de uma chave natural para um programa que instalará componentes COM; Quero dimensionar o tamanho para não gerenciar o ciclo de vida do GUID. Vou usar o MD5 e depois a classe UUID para obter uma string. (http://stackoverflow.com/questions/2190890/how-can-i-generate-guid-for-a-string-values/12867439 levanta esse problema).

De qualquer forma, java.util.UUID pode fornecer uma boa String a partir dos 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();

Ao contrário do PHP, onde você pode fazer um hash MD5 do seu texto, basta chamar a função md5, ou seja md5($text), em Java, isso foi um pouco complicado. Normalmente, eu o implementava chamando uma função que retorna o texto hash md5. Aqui está como eu a implementei: Primeiro crie uma função nomeada md5hashingdentro da sua classe principal, conforme indicado abaixo.

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;     
    }

Agora chame a função sempre que necessário, conforme indicado abaixo.

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

Aqui você pode ver que o hashtext é anexado com um zero para torná-lo compatível com o hash md5 no PHP.

O MD5 é perfeitamente adequado se você não precisar da melhor segurança e, se estiver fazendo algo como verificar a integridade dos arquivos, a segurança não é uma consideração. Nesse caso, convém considerar algo mais simples e rápido, como o Adler32, que também é suportado pelas bibliotecas Java.

este dá o md5 exato que você obtém da função md5 do mysql ou das funções md5 do php etc. É esse que eu uso (você pode alterar de acordo com suas necessidades)

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;            
    }

}

tente isto:

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)

Você pode gerar o hash MD5 para um determinado texto usando os métodos da MessageDigestclasse no java.securitypacote. Abaixo está o snippet 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);
   }
}

A saída da função MD5 é um hash de 128 bits representado por 32 números hexadecimais.

Caso esteja usando um banco de dados como o MySQL, você também pode fazer isso de uma maneira mais simples. A consulta Select MD5(“text here”)retornará o hash MD5 do texto entre colchetes.

Isto é o que eu vim aqui - uma função útil de scala que retorna uma sequência 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));
 }
}

Há um artigo no Codingkit sobre isso. Confira: http://codingkit.com/a/JAVA/2013/1020/2216.html