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

la classe MessageDigest peut vous fournir une instance du digest MD5.

lorsque vous travaillez avec les chaînes et les classes de crypto, assurez-vous de toujours spécifiez l'encodage dans lequel vous voulez la représentation byte. Si vous utilisez juste 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 oeil à la méthode .update(byte[]) qui peut être appelé à plusieurs reprises. Ensuite, appelez .digest() pour obtenir le hachage résultant.

vous pourriez également vouloir regarder le DigestUtils classe de l'apache codec communal projet, qui fournit des méthodes très pratiques pour créer des digestes MD5 ou SHA.

Si vous voulez vraiment la réponse comme une chaîne de caractères, 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 ne prends aucun crédit pour elle, mais c'est une solution qui fonctionne! Pour moi beaucoup d'autres codes n'ont pas fonctionné correctement, j'ai fini par manquer 0s dans le hachage. Celle-ci semble être la même que celle de 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ù l'hexagone: org.apache.commons.codec.binary.Hex de la Apache Commons projet .

je viens de télécharger commons-codec.jar et obtenu php parfait comme md5. Voici manuel .

il suffit de l'importer à votre projet et utiliser

String Url = "your_url";

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

et voilà.

j'ai trouvé ceci pour être le plus clair et concis:

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érer une représentation de chaîne de caractères 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 de goyaves :

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

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

une Autre mise en œuvre:

import javax.xml.bind.DatatypeConverter;

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

j'ai une classe (Hash) pour convertir le texte simple en hash dans les formats: md5 ou sha1, simillar que les 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");
    }
}

des Tests avec JUnit et PHP

Script PHP:

<?php

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

sortie script PHP:

MD5 :b10a8db164e0754105b7a99be72e3fe5
SHA1:0a4d55a8d778e5022fab701977c5d840bbc486d0

utilisant l'exemple et L'essai avec JUnit:

    public class HashTest {

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

}

en GitHub

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

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("%12x", i);         
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return null;
}

pas besoin de le rendre trop compliqué. DigestUtils fonctionne très bien et vous rend confortable tout en travaillant avec des châssis md5.

DigestUtils.md5Hex(_hash);

ou

DigestUtils.md5(_hash);

soit vous pouvez utiliser d'autres méthodes de cryptage telles que sha ou md.

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

je devrais ajouter que SHA1 a aussi des vulnérabilités théoriques, mais pas aussi graves. L'état actuel de l'art dans le hachage est qu'il ya un certain nombre de candidat remplacement des fonctions de hachage, mais aucune n'a encore émergé comme la meilleure pratique standard pour remplacer SHA1. Si, selon vos besoins, vous seriez bien avisé de rendre votre algorithme de hachage configurable afin qu'il puisse être remplacé à l'avenir.

il y a une classe DigestUtils dans printemps 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 mise en œuvre: Fast MD5 mise en Œuvre en Java

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

Je ne sais pas si c'est pertinent pour quelqu'un qui 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 sa MD5 à une valeur connue.

je voulais le faire avec des classes JRE seulement (Pas de Apache Commons ou similaire). Une recherche rapide sur le web ne m'a pas montré des exemples de code snippets faisant à la fois à la même temps, seulement chaque tâche séparément. Parce que cela nécessite de lire le même fichier deux fois, j'ai pensé qu'il pourrait être utile d'écrire un 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 Java parfait, mais je suppose que vous avez l'idée de toute façon):

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

regardez le 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 cela parce que je veux synthétiser des GUIDs à 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 et puis utiliser la classe UUID pour obtenir une chaîne de caractères. (http://stackoverflow.com/questions/2190890/how-can-i-generate-guid-for-a-string-values/12867439 soulève cette question).

en tout cas, java.util.UUID peut vous obtenir une belle chaîne de la MD5 octet.

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

MD5 est parfaitement bien 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 alors la sécurité n'est pas une considération. Dans ce cas, vous pourriez vouloir considérer quelque chose de plus simple et plus rapide, comme Adler32, qui est également supporté 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 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 il a été rendu un peu compliqué. Je l'ai habituellement implémenté en appelant une fonction qui renvoie le texte de hachage md5. Voici comment je l'ai implémenté, d'abord créer une fonction appelé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 lorsque 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 pour cela que 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épart: 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("%12X", hash);

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