Come posso generare un hash MD5?

Esiste un metodo per generare l'hash MD5 di una stringa in Java?

Hai bisogno java.security.MessageDigest.

Chiama MessageDigest.getInstance("MD5")per ottenere un'istanza MD5 MessageDigestche puoi usare.

Calcola l'hash eseguendo una delle seguenti operazioni:

• Alimenta l'intero input come a byte[]e calcola l'hash in un'unica operazione con md.digest(bytes).
• Dai da mangiare a MessageDigestun byte[]pezzo alla volta chiamando md.update(bytes). Quando hai finito di aggiungere byte di input, calcola l'hash con md.digest().

Il byte[]restituito da md.digest()è l'hash MD5.

La MessageDigestclasse può fornire un'istanza del digest MD5.

Quando lavori con le stringhe e le classi crypto assicurati di specificare sempre la codifica in cui vuoi che sia rappresentata la rappresentazione in byte. Se la usi solo string.getBytes(), utilizzerà la piattaforma predefinita. (Non tutte le piattaforme utilizzano le stesse impostazioni predefinite)

import java.security.*;

..

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

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

Se disponi di molti dati, dai un'occhiata al .update(byte[])metodo che può essere chiamato ripetutamente. Quindi chiama .digest()per ottenere l'hash risultante.

Se in realtà vuoi che la risposta sia una stringa anziché una matrice di byte, puoi sempre fare qualcosa del genere:

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

Potresti anche voler esaminare la classe DigestUtils del progetto codec commons apache , che fornisce metodi molto convenienti per creare digest MD5 o SHA.

Trovato questo:

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

sul sito qui sotto, non me lo merito, ma è una soluzione che funziona! Per me un sacco di altro codice non ha funzionato correttamente, ho finito per perdere 0 nell'hash. Questo sembra essere lo stesso di PHP. fonte: http://m2tec.be/blog/2010/02/03/java-md5-hex-0093

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

dove Hex è: org.apache.commons.codec.binary.Hexdal progetto Apache Commons .

Ho appena scaricato commons-codec.jar e ho ottenuto un PHP perfetto come md5. Ecco il manuale .

Basta importarlo nel tuo progetto e utilizzarlo

String Url = "your_url";

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

E il gioco è fatto.

Ho trovato che questo è il modo più chiaro e conciso per farlo:

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

Ho trovato questa soluzione molto più pulita in termini di recupero di una rappresentazione String da 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));
    }
}

Il codice è stato estratto da qui .

Un'altra opzione è quella di utilizzare i metodi di hash guava :

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

Comodo se stai già usando Guava (che se non lo sei, probabilmente dovresti esserlo).

Un'altra implementazione:

import javax.xml.bind.DatatypeConverter;

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

Ho una classe (hash) per convertire il testo normale in hash nei formati: md5 o sha1, simillar che funzioni 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 con JUnit e PHP

Script PHP:

<?php

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

Output script PHP:

MD5 :b10a8db164e0754105b7a99be72e3fe5
SHA1:0a4d55a8d778e5022fab701977c5d840bbc486d0

Utilizzando esempio e test con JUnit:

    public class HashTest {

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

}

Codice in GitHub

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

Non c'è bisogno di renderlo troppo complicato.
DigestUtils funziona bene e ti mette a tuo agio mentre lavori con gli md5hash.

DigestUtils.md5Hex(_hash);

o

DigestUtils.md5(_hash);

È possibile utilizzare qualsiasi altro metodo di crittografia come shao md.

La mia risposta non molto rivelatrice:

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

C'è anche una DigestUtilslezione in primavera :

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

Questa classe contiene il metodo md5DigestAsHex()che svolge il lavoro.

Puoi provare a seguire. Vedi i dettagli e scarica i codici qui: 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 risposta di Bombe è corretta, tuttavia nota che, a meno che tu non debba assolutamente usare MD5 (ad es. Forzato per l'interoperabilità), una scelta migliore è SHA1 poiché MD5 presenta punti deboli per un uso a lungo termine.

Dovrei aggiungere che SHA1 ha anche vulnerabilità teoriche, ma non così gravi. L'attuale stato dell'arte nell'hash è che esistono numerose funzioni hash sostitutive candidate ma nessuna è ancora emersa come la migliore pratica standard per sostituire SHA1. Quindi, a seconda delle tue esigenze, ti consigliamo di rendere configurabile il tuo algoritmo hash in modo che possa essere sostituito in futuro.

Un'altra implementazione: implementazione MD5 veloce in Java

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

Non so se questo è rilevante per chiunque legga questo, ma ho appena avuto il problema che volevo

• scarica un file da un determinato URL e
• confronta il suo MD5 con un valore noto.

Volevo farlo solo con le classi JRE (no Apache Commons o simili). Una rapida ricerca sul Web non mi ha mostrato frammenti di codice di esempio che eseguivano entrambi contemporaneamente, ma solo ciascuna attività separatamente. Poiché questo richiede di leggere lo stesso file due volte, ho pensato che sarebbe valsa la pena scrivere del codice che unifica entrambe le attività, calcolando al volo la somma di controllo durante il download del file. Questo è il mio risultato (scusate se non è perfetto Java, ma credo che abbiate preso l'idea comunque):

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

Dai un'occhiata al seguente link, l'esempio ottiene un hash MD5 di un'immagine fornita: hash MD5 di un'immagine

Per quello che vale, mi sono imbattuto in questo perché voglio sintetizzare GUID da una chiave naturale per un programma che installerà componenti COM; Voglio sintetizzare in modo da non gestire il ciclo di vita del GUID. Userò MD5 e poi userò la classe UUID per estrarne una stringa. (http://stackoverflow.com/questions/2190890/how-can-i-generate-guid-for-a-string-values/12867439 solleva questo problema).

In ogni caso, java.util.UUID può ottenere una bella stringa dai byte 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 differenza di PHP in cui è possibile eseguire un hash MD5 del testo semplicemente chiamando la funzione md5, ad esempio md5($text), in Java è stato reso un po 'complicato. Di solito l'ho implementato chiamando una funzione che restituisce il testo hash md5. Ecco come l'ho implementato, per prima cosa crea una funzione chiamata md5hashingall'interno della tua classe principale come indicato di seguito.

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

Ora chiama la funzione ogni volta che è necessario come indicato di seguito.

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

Qui puoi vedere che hashtext è aggiunto con uno zero per farlo corrispondere con hash md5 in PHP.

MD5 è perfetto se non hai bisogno della migliore sicurezza e se stai facendo qualcosa come il controllo dell'integrità dei file, la sicurezza non è una considerazione. In tal caso potresti voler considerare qualcosa di più semplice e veloce, come Adler32, che è supportato anche dalle librerie Java.

questo fornisce l'esatto md5 come si ottiene dalla funzione md5 di mysql o dalle funzioni md5 di php ecc. Questo è quello che uso (puoi cambiare in base alle tue esigenze)

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

}

prova questo:

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)

È possibile generare l'hash MD5 per un determinato testo facendo uso dei metodi nella MessageDigestclasse nel java.securitypacchetto. Di seguito è riportato lo snippet di codice 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);
   }
}

L'output della funzione MD5 è un hash a 128 bit rappresentato da 32 numeri esadecimali.

Nel caso, se si utilizza un database come MySQL, è possibile farlo anche in un modo più semplice. La query Select MD5(“text here”)restituirà l'hash MD5 del testo tra parentesi.

Questo è ciò per cui sono venuto qui: una comoda funzione scala che restituisce una stringa di 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));
 }
}

C'è un articolo su Codingkit al riguardo. Scopri: http://codingkit.com/a/JAVA/2013/1020/2216.html