Obtenir le total de contrôle MD5 D'un fichier en Java

Utiliser DigestUtils à partir de Apache Commons Codec de la bibliothèque:

FileInputStream fis = new FileInputStream(new File("foo"));
String md5 = org.apache.commons.codec.digest.DigestUtils.md5Hex(fis);
fis.close();

il y a un exemple à Java-How-to de Real en utilisant la classe MessageDigest .

Vérifiez cette page pour les exemples utilisant CRC32 et SHA-1 ainsi.

import java.io.*;
import java.security.MessageDigest;

public class MD5Checksum {

   public static byte[] createChecksum(String filename) throws Exception {
       InputStream fis =  new FileInputStream(filename);

       byte[] buffer = new byte[1024];
       MessageDigest complete = MessageDigest.getInstance("MD5");
       int numRead;

       do {
           numRead = fis.read(buffer);
           if (numRead > 0) {
               complete.update(buffer, 0, numRead);
           }
       } while (numRead != -1);

       fis.close();
       return complete.digest();
   }

   // see this How-to for a faster way to convert
   // a byte array to a HEX string
   public static String getMD5Checksum(String filename) throws Exception {
       byte[] b = createChecksum(filename);
       String result = "";

       for (int i=0; i < b.length; i++) {
           result += Integer.toString( ( b[i] & 0xff ) + 0x100, 16).substring( 1 );
       }
       return result;
   }

   public static void main(String args[]) {
       try {
           System.out.println(getMD5Checksum("apache-tomcat-5.5.17.exe"));
           // output :
           //  0bb2827c5eacf570b6064e24e0e6653b
           // ref :
           //  http://www.apache.org/dist/
           //          tomcat/tomcat-5/v5.5.17/bin
           //              /apache-tomcat-5.5.17.exe.MD5
           //  0bb2827c5eacf570b6064e24e0e6653b *apache-tomcat-5.5.17.exe
       }
       catch (Exception e) {
           e.printStackTrace();
       }
   }
}

Le com.Google.commun.hash API offres:

• une API conviviale unifiée pour toutes les fonctions de hachage
• Seedable 32 et 128 bits implémentations de murmur3
• md5(), sha1(), sha256(), SHA512() adaptateurs, changer une seule ligne de code pour passer entre ceux-ci, et murmure.
• goodFastHash(int bits), pour quand vous ne vous souciez pas ce que l'algorithme que vous utilisez
• Utilités générales pour les instances de HashCode, comme combineOrdered / combineUnordered

Lire le Guide de l'Utilisateur ( IO Expliqué , "1519210920 de" Hachage Expliqué ).

Pour votre cas d'utilisation Files.hash() calcule et renvoie le digest de la valeur pour un fichier.

, par exemple a sha-1 calcul par digestion (changer SHA-1 en MD5 en MD5) get MD5 digest)

HashCode hc = Files.asByteSource(file).hash(Hashing.sha1());
"SHA-1: " + hc.toString();

notez que crc32 est beaucoup plus rapide que md5 , donc utilisez crc32 si vous n'avez pas besoin d'un checksum cryptographique sécurisé. Notez également que md5 ne doit pas être utilisé pour stocker les mots de passe et similaires, car il est trop facile de forcer, pour les mots de passe utiliser bcrypt , scrypt ou sha-256 à la place.

Pour la protection à long terme avec des hachages un Merkle signature scheme ajoute à la sécurité et à La Poste de la Cryptographie Quantique Groupe d'Étude commandité par la Commission Européenne a recommandé l'utilisation de cette cryptographie pour la protection à long terme contre les ordinateurs quantiques ( ref ).

Note que crc32 a un taux de collision plus élevée que les autres.

utilisant nio2 (Java 7+) et aucune bibliothèque externe:

byte[] b = Files.readAllBytes(Paths.get("/path/to/file"));
byte[] hash = MessageDigest.getInstance("MD5").digest(b);

pour comparer le résultat avec un total de contrôle attendu:

String expected = "2252290BC44BEAD16AA1BF89948472E8";
String actual = DatatypeConverter.printHexBinary(hash);
System.out.println(expected.equalsIgnoreCase(actual) ? "MATCH" : "NO MATCH");

Guava fournit maintenant une nouvelle API de hachage cohérente qui est beaucoup plus conviviale que les divers API de hachage fournis dans le JDK. Voir "151940920 De" Hachage Expliqué . Pour un fichier, vous pouvez obtenir la somme MD5, CRC32 (avec la version 14.0+) ou beaucoup d'autres hachages facilement:

HashCode md5 = Files.hash(file, Hashing.md5());
byte[] md5Bytes = md5.asBytes();
String md5Hex = md5.toString();

HashCode crc32 = Files.hash(file, Hashing.crc32());
int crc32Int = crc32.asInt();

// the Checksum API returns a long, but it's padded with 0s for 32-bit CRC
// this is the value you would get if using that API directly
long checksumResult = crc32.padToLong();

Ok. J'ai dû ajouter. Une implémentation en ligne pour ceux qui ont déjà la dépendance de Spring et D'Apache Commons ou qui prévoient de l'ajouter:

DigestUtils.md5DigestAsHex(FileUtils.readFileToByteArray(file))

et Apache commons option (crédit @duleshi):

DigestUtils.md5Hex(FileUtils.readFileToByteArray(file))

J'espère que ça aidera quelqu'un.

une approche simple sans bibliothèques tierces utilisant Java 7

String path = "your complete file path";
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(Files.readAllBytes(Paths.get(path)));
byte[] digest = md.digest();

Si vous avez besoin d'imprimer ce tableau d'octets. Utiliser comme ci-dessous

System.out.println(Arrays.toString(digest));

si vous avez besoin d'une chaîne hexagonale. Utiliser comme ci-dessous

String digestInHex = DatatypeConverter.printHexBinary(digest).toUpperCase();
System.out.println(digestInHex);

où DatatypeConverter est javax.XML.lier.DatatypeConverter

j'ai récemment dû faire cela pour juste une chaîne dynamique, MessageDigest peut représenter le hachage de nombreuses façons. Pour obtenir la signature du fichier comme vous l'obtiendriez avec la commande md5sum je devais faire quelque chose comme ceci:

try {
   String s = "TEST STRING";
   MessageDigest md5 = MessageDigest.getInstance("MD5");
   md5.update(s.getBytes(),0,s.length());
   String signature = new BigInteger(1,md5.digest()).toString(16);
   System.out.println("Signature: "+signature);

} catch (final NoSuchAlgorithmException e) {
   e.printStackTrace();
}

cela ne répond évidemment pas à votre question sur la façon de le faire spécifiquement pour un fichier, la réponse ci-dessus traite de ce calme bien. Je viens de passer beaucoup de temps obtenir la somme pour ressembler à la plupart de l'application l'afficher, et pensé que vous pourriez rencontrer les mêmes problèmes.

public static void main(String[] args) throws Exception {
    MessageDigest md = MessageDigest.getInstance("MD5");
    FileInputStream fis = new FileInputStream("c:\apache\cxf.jar");

    byte[] dataBytes = new byte[1024];

    int nread = 0;
    while ((nread = fis.read(dataBytes)) != -1) {
        md.update(dataBytes, 0, nread);
    };
    byte[] mdbytes = md.digest();
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < mdbytes.length; i++) {
        sb.append(Integer.toString((mdbytes[i] & 0xff) + 0x100, 16).substring(1));
    }
    System.out.println("Digest(in hex format):: " + sb.toString());
}

Ou vous pouvez obtenir plus d'informations http://www.asjava.com/core-java/java-md5-example /

nous utilisions un code qui ressemble au code ci-dessus dans un post précédent en utilisant

...
String signature = new BigInteger(1,md5.digest()).toString(16);
...

cependant, attention à utiliser BigInteger.toString() ici, car il tronquera les zéros de tête... (pour un exemple, essayez s = "27" , la somme de contrôle doit être "02e74f10e0327ad868d138f2b4fdd6f0" )

j'appuie la suggestion D'Utiliser Apache Commons Codec, j'ai remplacé notre propre code avec cela.

public static String MD5Hash(String toHash) throws RuntimeException {
   try{
       return String.format("%032x", // produces lower case 32 char wide hexa left-padded with 0
      new BigInteger(1, // handles large POSITIVE numbers 
           MessageDigest.getInstance("MD5").digest(toHash.getBytes())));
   }
   catch (NoSuchAlgorithmException e) {
      // do whatever seems relevant
   }
}

méthode Java très rapide et propre qui ne repose pas sur des bibliothèques externes:

(il suffit de remplacer MD5 par SHA-1, SHA-256, SHA-384 ou SHA-512 si vous les voulez)

public String calcMD5() throws Exception{
        byte[] buffer = new byte[8192];
        MessageDigest md = MessageDigest.getInstance("MD5");

        DigestInputStream dis = new DigestInputStream(new FileInputStream(new File("Path to file")), md);
        try {
            while (dis.read(buffer) != -1);
        }finally{
            dis.close();
        }

        byte[] bytes = md.digest();

        // bytesToHex-method
        char[] hexChars = new char[bytes.length * 2];
        for ( int j = 0; j < bytes.length; j++ ) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = hexArray[v >>> 4];
            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
        }

        return new String(hexChars);
}

une Autre mise en œuvre: Fast MD5 mise en Œuvre en Java

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

Standard de Java Runtime Environnement :

public String checksum(File file) {
  try {
    InputStream fin = new FileInputStream(file);
    java.security.MessageDigest md5er =
        MessageDigest.getInstance("MD5");
    byte[] buffer = new byte[1024];
    int read;
    do {
      read = fin.read(buffer);
      if (read > 0)
        md5er.update(buffer, 0, read);
    } while (read != -1);
    fin.close();
    byte[] digest = md5er.digest();
    if (digest == null)
      return null;
    String strDigest = "0x";
    for (int i = 0; i < digest.length; i++) {
      strDigest += Integer.toString((digest[i] & 0xff) 
                + 0x100, 16).substring(1).toUpperCase();
    }
    return strDigest;
  } catch (Exception e) {
    return null;
  }
}

le résultat est égal à Linux md5sum utility.

String checksum = DigestUtils.md5Hex(new FileInputStream(filePath));

Voici une fonction simple qui enroule autour du code de Sunil pour qu'il prenne un fichier comme paramètre. La fonction n'a pas besoin de bibliothèques externes, mais elle nécessite Java 7.

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import javax.xml.bind.DatatypeConverter;

public class Checksum {

    /**
     * Generates an MD5 checksum as a String.
     * @param file The file that is being checksummed.
     * @return Hex string of the checksum value.
     * @throws NoSuchAlgorithmException
     * @throws IOException
     */
    public static String generate(File file) throws NoSuchAlgorithmException,IOException {

        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        messageDigest.update(Files.readAllBytes(file.toPath()));
        byte[] hash = messageDigest.digest();

        return DatatypeConverter.printHexBinary(hash).toUpperCase();
    }

    public static void main(String argv[]) throws NoSuchAlgorithmException, IOException {
        File file = new File("/Users/foo.bar/Documents/file.jar");          
        String hex = Checksum.generate(file);
        System.out.printf("hex=%s\n", hex);            
    }


}

exemple de sortie:

hex=B117DD0C3CBBD009AC4EF65B6D75C97B

si vous utilisez ANT pour construire, c'est très simple. Ajoutez ce qui suit à votre Compilation.xml:

<checksum file="${jarFile}" todir="${toDir}"/>

où jarFile est le JAR contre lequel vous voulez générer le MD5, et toDir est le répertoire dans lequel vous voulez placer le fichier MD5.

pour en savoir plus, cliquez ici.

Google guava fournit une nouvelle API. Trouvez celui ci-dessous:

public static HashCode hash(File file,
            HashFunction hashFunction)
                     throws IOException

Computes the hash code of the file using hashFunction.

Parameters:
    file - the file to read
    hashFunction - the hash function to use to hash the data
Returns:
    the HashCode of all of the bytes in the file
Throws:
    IOException - if an I/O error occurs
Since:
    12.0

public static String getMd5OfFile(String filePath)
{
    String returnVal = "";
    try 
    {
        InputStream   input   = new FileInputStream(filePath); 
        byte[]        buffer  = new byte[1024];
        MessageDigest md5Hash = MessageDigest.getInstance("MD5");
        int           numRead = 0;
        while (numRead != -1)
        {
            numRead = input.read(buffer);
            if (numRead > 0)
            {
                md5Hash.update(buffer, 0, numRead);
            }
        }
        input.close();

        byte [] md5Bytes = md5Hash.digest();
        for (int i=0; i < md5Bytes.length; i++)
        {
            returnVal += Integer.toString( ( md5Bytes[i] & 0xff ) + 0x100, 16).substring( 1 );
        }
    } 
    catch(Throwable t) {t.printStackTrace();}
    return returnVal.toUpperCase();
}

voici une variante pratique qui utilise InputStream.transferTo() de Java 9, et OutputStream.nullOutputStream() de Java 11. Il ne nécessite pas de bibliothèques externes et n'a pas besoin de charger tout le fichier en mémoire.

public static String hashFile(String algorithm, File f) throws IOException, NoSuchAlgorithmException {
    MessageDigest md = MessageDigest.getInstance(algorithm);

    try(BufferedInputStream in = new BufferedInputStream((new FileInputStream(f)));
        DigestOutputStream out = new DigestOutputStream(OutputStream.nullOutputStream(), md)) {
        in.transferTo(out);
    }

    String fx = "%0" + (md.getDigestLength()*2) + "x";
    return String.format(fx, new BigInteger(1, md.digest()));
}

et

hashFile("SHA-512", Path.of("src", "test", "resources", "some.txt").toFile());

retourne

"e30fa2784ba15be37833d569280e2163c6f106506dfb9b07dde67a24bfb90da65c661110cf2c5c6f71185754ee5ae3fd83a5465c92f72abd888b03187229da29"