Comment puis-je générer un hachage MD5?

La classe MessageDigest peut vous fournir une instance du condensé MD5.

Lorsque vous travaillez avec des chaînes et les classes crypto, assurez-vous de toujours spécifier l'encodage dans lequel vous voulez la représentation d'octets. Si vous utilisez simplement string.getBytes(), il utilisera la plate-forme par défaut. (Toutes les plateformes n'utilisent pas les mêmes valeurs par défaut)

import java.security.*;

..

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

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

Si vous avez beaucoup de données, jetez un œil à la méthode .update(byte[]) qui peut être appelée à plusieurs reprises. Ensuite, appelez .digest() pour obtenir le hachage résultant.

Vous pouvez également regarder la classe digesttutilsdu projet apache commons codec, qui fournit des méthodes très pratiques pour créer des résumés MD5 ou SHA.

Si vous voulez réellement que la réponse soit une chaîne par opposition à un tableau d'octets, vous pouvez toujours faire quelque chose comme ceci:

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

Trouvé ceci:

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

Sur le site ci-dessous, je n'en prends aucun crédit, mais c'est une solution qui fonctionne! Pour moi, beaucoup d'autres codes ne fonctionnaient pas correctement, j'ai fini par manquer 0 dans le hachage. Celui-ci semble être le même que PHP. source: http://m2tec.be/blog/2010/02/03/java-md5-hex-0093

Voici comment je l'utilise:

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

Où Hex est: org.apache.commons.codec.binary.Hexdu projet Apache Commons.

Je viens de télécharger communes-codec.jar et obtenu php parfait comme md5. Voicimanuel .

Importez-le simplement dans votre projet et utilisez

String Url = "your_url";

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

Et là vous l'avez.

J'ai trouvé que c'était la façon la plus claire et la plus concise de le faire:

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

A trouvé cette solution qui est beaucoup plus propre en termes de récupération d'une représentation de chaîne à partir d'un hachage 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));
    }
}

Le code a été extrait de ici.

Une autre option consiste à utiliser les méthodes de hachage Guava :

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

Pratique si vous utilisez déjà de la goyave (ce qui si vous ne l'êtes pas, vous devriez probablement l'être).

Une autre implémentation:

import javax.xml.bind.DatatypeConverter;

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

J'ai une classe (Hash) pour convertir du texte brut en hash dans les formats: md5 ou sha1, similaire aux fonctions 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");
    }
}

Test avec JUnit et PHP

Script PHP:

<?php

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

Script PHP de sortie:

MD5 :b10a8db164e0754105b7a99be72e3fe5
SHA1:0a4d55a8d778e5022fab701977c5d840bbc486d0

Utilisation de l'exemple et des tests avec JUnit:

    public class HashTest {

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

}

Le Code sur GitHub

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

Ma réponse pas très révélatrice:

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

Pas besoin de le rendre trop compliqué. Digesttutils fonctionne très bien et vous rend confortable tout en travaillant avec des hachages md5.

DigestUtils.md5Hex(_hash);

Ou

DigestUtils.md5(_hash);

Vous pouvez utiliser toutes les autres méthodes de cryptage telles que sha ou md.

La réponse de Bombe est correcte, mais notez que sauf si vous devez absolument utiliser MD5 (par exemple forcé pour l'interopérabilité), un meilleur choix est SHA1 car MD5 a des faiblesses pour une utilisation à long terme.

Je dois ajouter que SHA1 a également des vulnérabilités théoriques, mais pas aussi graves. L'état actuel de l'art dans le hachage est qu'il existe un certain nombre de fonctions de hachage de remplacement candidates, mais aucune n'a encore émergé comme la meilleure pratique standard pour remplacer SHA1. Ainsi, en fonction de vos besoins vous serait bien conseillé de rendre votre algorithme de hachage configurable afin qu'il puisse être remplacé à l'avenir.

Il y a une classe DigestUtils dans Spring aussi:

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

Cette classe contient la méthode md5DigestAsHex() qui fait le travail.

Vous pouvez essayer de suivre. Voir les détails et télécharger les codes ici: 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();
}
}

Une autre implémentation: Implémentation rapide de MD5 en Java

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

Je ne sais pas si cela est pertinent pour quiconque lit ceci, mais j'ai juste eu le problème que je voulais

• télécharger un fichier à partir d'une URL donnée et
• comparez son MD5 à une valeur connue.

Je voulais le faire uniquement avec les classes JRE (pas d'Apache Commons ou similaire). Une recherche rapide sur le Web ne m'a pas montré d'exemples d'extraits de code faisant les deux en même temps, seulement chaque tâche séparément. Parce que cela nécessite de lire le même fichier deux fois, je l'ai pensé cela pourrait valoir la peine d'écrire du code qui unifie les deux tâches, en calculant la somme de contrôle à la volée lors du téléchargement du fichier. C'est mon résultat (désolé si ce n'est pas parfait Java, mais je suppose que vous avez quand même l'idée):

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

Jetez un oeil au lien suivant, l'exemple obtient un hachage MD5 d'une image fournie: Hachage MD5 d'une image

Pour ce que ça vaut, je suis tombé sur ça parce que je veux synthétiser des GUID à partir d'une clé naturelle pour un programme qui installera des composants COM; Je veux syhthesize afin de ne pas gérer le cycle de vie des GUID. Je vais utiliser MD5, puis utiliser la classe UUID pour en extraire une chaîne. (http://stackoverflow.com/questions/2190890/how-can-i-generate-guid-for-a-string-values/12867439 soulève ce problème).

En tout cas, java.util.UUID peut vous obtenir une belle chaîne à partir des octets MD5.

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

MD5 est parfaitement correct si vous n'avez pas besoin de la meilleure sécurité, et si vous faites quelque chose comme vérifier l'intégrité des fichiers, la sécurité n'est pas une considération. Dans ce cas, vous voudrez peut-être envisager quelque chose de plus simple et plus rapide, comme Adler32, qui est également pris en charge par les bibliothèques Java.

Essayez ceci:

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.*;
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();

Celui-ci donne le md5 exact que vous obtenez de la fonction md5 de mysql ou des fonctions md5 de php, etc. C'est celui que j'utilise (vous pouvez changer selon vos besoins)

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

}

Contrairement à PHP où vous pouvez faire un cryptage md5 de votre texte en appelant simplement la fonction md5 ie md5($text), en java, cela a été un peu compliqué. Je l'ai généralement implémenté en appelant une fonction qui renvoie le texte de hachage md5. Voici comment je l'ai implémenté, créez d'abord une fonction nommée md5encryption dans votre classe principale comme indiqué ci-dessous .

public static String md5encryption(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;     
    }

Appelez maintenant la fonction quand vous en avez besoin comme indiqué ci-dessous.

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

Ici vous pouvez voir que hashtext est ajouté avec un zéro pour le faire correspondre avec le cryptage md5 en PHP.

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)

C'est ce pour quoi je suis venu ici - une fonction scala pratique qui renvoie une chaîne de hachage 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));
 }
}

Il y a un article sur Codingkit à ce sujet. Découvrez: http://codingkit.com/a/JAVA/2013/1020/2216.html

private String hashuj(String dane) throws ServletException{
    try {
        MessageDigest m = MessageDigest.getInstance("MD5");
        byte[] bufor = dane.getBytes();
        m.update(bufor,0,bufor.length);
        BigInteger hash = new BigInteger(1,m.dige`enter code here`st());
        return String.format("%1$032X", hash);

    } catch (NoSuchAlgorithmException nsae) {
        throw new ServletException("Algorytm szyfrowania nie jest obsługiwany!");
    }
}