Comment générer un hachage MD5?

Existe-t-il une méthode pour générer le hachage MD5 d'une chaîne en Java?

Vous en avez besoin java.security.MessageDigest.

Appel MessageDigest.getInstance("MD5") pour obtenir une instance MD5 que MessageDigestvous pouvez utiliser.

Le calcul du hachage en effectuant l'une des actions suivantes:

• Alimentez l'intégralité de l'entrée en tant que byte[] et calculez le hachage en une seule opération avec md.digest(bytes).
• Nourrir l' MessageDigestun byte[]morceau à la fois en appelant md.update(bytes). Lorsque vous avez terminé d'ajouter des octets d'entrée, calculez le hachage avec md.digest() .

Le byte[]retourné par md.digest()est le hachage MD5.

La MessageDigestclasse peut vous fournir une instance du résumé MD5.

Lorsque vous travaillez avec des chaînes et les classes de chiffrement, assurez-vous de toujours spécifier l'encodage dans lequel vous souhaitez que la représentation en octets soit utilisée. Si vous l'utilisez, string.getBytes()elle 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 .update(byte[])méthode qui peut être appelée à plusieurs reprises. Appelez ensuite .digest()pour obtenir le hachage résultant.

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

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

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 des 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ù se trouve Hex: org.apache.commons.codec.binary.Hexdu projet Apache Commons .

Je viens de télécharger commons-codec.jar et j'ai obtenu un php parfait comme md5. Voici le manuel .

Importez-le simplement dans votre projet et utilisez

String Url = "your_url";

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

Et voila.

J'ai trouvé que c'était la façon la plus claire et 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()));

Trouvé cette solution qui est beaucoup plus propre en termes de récupération d'une représentation String à 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 d' ici .

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

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

Pratique si vous utilisez déjà la goyave (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 hachage dans les formats: md5 ou sha1, simillar que php fonctionne ( 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

Utiliser l'exemple et tester avec JUnit:

    public class HashTest {

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

}

Code dans GitHub

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

Pas besoin de compliquer les choses.
DigestUtils fonctionne bien et vous rend confortable lorsque vous travaillez avec des md5hachages.

DigestUtils.md5Hex(_hash);

ou

DigestUtils.md5(_hash);

Soit vous pouvez utiliser toute autre méthode de cryptage telle que shaou md.

Ma réponse peu 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;
}

Il y a un DigestUtils classe au printemps :

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

La réponse de Bombe est correcte, cependant, notez qu'à moins que vous ne deviez absolument utiliser MD5 (par exemple forcé sur vous 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 la technique du hachage est qu'il existe un certain nombre de fonctions de hachage de remplacement candidates, mais aucune n'est encore apparue comme la meilleure pratique standard pour remplacer SHA1. Ainsi, selon vos besoins, il serait judicieux de rendre votre algorithme de hachage configurable afin qu'il puisse être remplacé à l'avenir.

Une autre implémentation: Fast MD5 Implementation in Java

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

Je ne sais pas si cela est pertinent pour quiconque lit ceci, mais je viens de rencontrer le problème que je voulais

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

Je voulais le faire avec des classes JRE uniquement (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, uniquement chaque tâche séparément. Parce que cela nécessite de lire deux fois le même fichier, j'ai pensé qu'il pourrait être utile d'écrire du code qui unifie les deux tâches, calculant la somme de contrôle à la volée lors du téléchargement du fichier. Voici mon résultat (désolé si ce n'est pas du Java parfait, 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 œil au lien suivant, l'exemple obtient un hachage MD5 d'une image fournie: Hash MD5 d'une image

Pour ce que ça vaut, je suis tombé dessus parce que je veux synthétiser des GUID à partir d'une clé naturelle pour un programme qui installera des composants COM; Je souhaite créer une taille afin de ne pas gérer le cycle de vie du GUID. J'utiliserai MD5, puis j'utiliserai 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).

Dans tous les cas, java.util.UUID peut vous obtenir une jolie chaîne à partir des octets 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();

Contrairement à PHP où vous pouvez faire un hachage MD5 de votre texte en appelant simplement la fonction md5, c'est md5($text)-à- dire qu'en Java, cela a été rendu 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 à l' md5hashingintérieur de votre classe principale comme indiqué ci-dessous.

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

Appelez maintenant la fonction chaque fois que vous en avez besoin, comme indiqué ci-dessous.

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

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

MD5 est parfaitement bien si vous n'avez pas besoin de la meilleure sécurité, et si vous faites quelque chose comme la vérification de 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.

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 en fonction de 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;            
    }

}

essaye ça:

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)

Vous pouvez générer un hachage MD5 pour un texte donné en utilisant les méthodes de la MessageDigestclasse du java.securitypackage. Voici l'extrait de code complet,

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 sortie de la fonction MD5 est un hachage de 128 bits représenté par 32 nombres hexadécimaux.

Dans le cas, si vous utilisez une base de données comme MySQL, vous pouvez également le faire de manière plus simple. La requête Select MD5(“text here”)renverra le hachage MD5 du texte entre crochets.

Voici pourquoi 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. Consultez: http://codingkit.com/a/JAVA/2013/1020/2216.html