Comment calculer la somme de contrôle md5 sur l'annuaire avec java ou groovy?

Je suis à la recherche d'utiliser java ou groovy pour obtenir la somme de contrôle md5 d'un répertoire complet.

Je dois copier les répertoires de la source à la cible, de la somme de contrôle de la source et de la cible, et après supprimer les répertoires source.

J'ai trouver ce script pour les fichiers, mais comment faire la même chose avec les annuaires ?

import java.security.MessageDigest

def generateMD5(final file) {
    MessageDigest digest = MessageDigest.getInstance("MD5")
    file.withInputStream(){ is ->
        byte[] buffer = new byte[8192]
        int read = 0
        while( (read = is.read(buffer)) > 0) {
            digest.update(buffer, 0, read);
        }
    }
    byte[] md5sum = digest.digest()
    BigInteger bigInt = new BigInteger(1, md5sum)

    return bigInt.toString(16).padLeft(32, '0')
}

Est-il une meilleure approche ?

Vous devez utiliser l'un des org.apache.commons.codec.digest.DigestUtils.md5Hex méthodes préférence pour le code ci-dessus
Je trouve FastMD5, vraiment facile de trouver le fichier MD5 : Chaîne de hash = MD5.asHex(MD5.getHash(new File(filename)))); de plus en Plus facile à utiliser et plus Rapide.

OriginalL'auteur Fabien Barbier | 2010-06-09

9

J'ai eu la même exigence et choisi mon répertoire de hachage' être un hachage MD5 de la concaténation de flux de tous les (non -) du répertoire des fichiers dans le répertoire. Comme crozin mentionné dans les commentaires sur une question similaire, vous pouvez utiliser SequenceInputStream à agir comme un ruisseau de la concaténation d'une charge d'autres flux. Je suis en utilisant Apache Commons Codec pour l'algorithme MD5.

Fondamentalement, vous recurse à travers l'arborescence du répertoire, l'ajout de FileInputStream des cas, à un Vector pour les non-répertoire de fichiers. Vector alors facilement a la elements() d'une méthode à l' Enumeration que SequenceInputStream doit parcourir. L'algorithme MD5, cela apparaît comme un InputStream.

Une chasse aux sorcières, c'est que vous avez besoin des fichiers présentés dans le même ordre à chaque fois pour le hachage être le même avec les mêmes entrées. Le listFiles() méthode dans File ne garantit pas une commande, j'ai donc trier par nom de fichier.

Je faisais cela pour SVN contrôlé fichiers, et je voulais éviter le hachage de l'caché fichiers SVN, j'ai donc mis en place un indicateur pour éviter les fichiers cachés.

Pertinentes du code de base est comme ci-dessous. (Évidemment, il pourrait être "blindé".)
```
import org.apache.commons.codec.digest.DigestUtils;
import java.io.*;
import java.util.*;
public String calcMD5HashForDir(File dirToHash, boolean includeHiddenFiles) {
assert (dirToHash.isDirectory());
Vector<FileInputStream> fileStreams = new Vector<FileInputStream>();
System.out.println("Found files for hashing:");
collectInputStreams(dirToHash, fileStreams, includeHiddenFiles);
SequenceInputStream seqStream = 
new SequenceInputStream(fileStreams.elements());
try {
String md5Hash = DigestUtils.md5Hex(seqStream);
seqStream.close();
return md5Hash;
}
catch (IOException e) {
throw new RuntimeException("Error reading files to hash in "
+ dirToHash.getAbsolutePath(), e);
}
}
private void collectInputStreams(File dir,
List<FileInputStream> foundStreams,
boolean includeHiddenFiles) {
File[] fileList = dir.listFiles();        
Arrays.sort(fileList,               //Need in reproducible order
new Comparator<File>() {
public int compare(File f1, File f2) {                       
return f1.getName().compareTo(f2.getName());
}
});
for (File f : fileList) {
if (!includeHiddenFiles && f.getName().startsWith(".")) {
//Skip it
}
else if (f.isDirectory()) {
collectInputStreams(f, foundStreams, includeHiddenFiles);
}
else {
try {
System.out.println("\t" + f.getAbsolutePath());
foundStreams.add(new FileInputStream(f));
}
catch (FileNotFoundException e) {
throw new AssertionError(e.getMessage()
+ ": file should never not be found!");
}
}
}
}
```
Bonne réponse - j'ai décidé d'utiliser votre code. Notez bien qu'il n'est pas portable - vérification des fichiers cachés doit être fondée sur des "isHidden", pas sur le nom de fichier. Dans certains cas, il est probablement préférable de vérifier à la fois comme certains programmes (par exemple, Eclipse) enregistrer les fichiers de travail en commençant par un point (par exemple:.classpath) sans effectuer cachés sur la non-systèmes d'exploitation Unix.
Oui, bon point pour le non-portabilité et heureux que vous avez trouvé le bout de code utile. Ce morceau a été rapide et sale code; je dis "Évidemment, il pourrait être "blindé"" : -)
La réponse est génial, mais il manque si les noms de fichiers sont modifiés, en conservant l'ordre alphabétique, de sorte que nous pouvons prendre un plus hachage avec chemin d'accès absolu du fichier.

OriginalL'auteur Stuart Rossiter
4

J'ai fait une fonction pour calculer la somme de contrôle MD5 sur le Répertoire :

Tout d'abord, je suis en utilisant FastMD5: http://www.twmacinta.com/myjava/fast_md5.php

Voici mon code :
```
  def MD5HashDirectory(String fileDir) {
MD5 md5 = new MD5();
new File(fileDir).eachFileRecurse{ file ->
if (file.isFile()) {
String hashFile = MD5.asHex(MD5.getHash(new File(file.path)));
md5.Update(hashFile, null);
}
}
String hashFolder = md5.asHex();
return hashFolder
}
```
Avec groovy (sans doute aussi en Java), il peut être utile d'utiliser Ant (ou mieux Gant). Voir : ant.apache.org/manual/dirtasks.html
C'est en fait le hachage hash du contenu des fichiers, plutôt que de simplement le hachage du contenu.

OriginalL'auteur Fabien Barbier
2

HashCopy est une application Java. Il peut générer et vérifier le MD5 et SHA sur un seul fichier ou d'un répertoire de façon récursive. Je ne suis pas sûr si elle a une API. Il peut être téléchargé à partir de http://www.jdxsoftware.org.

Belle application, mais a besoin d'une licence si HashCopy est utilisé à des fins commerciales.

OriginalL'auteur William Leng

Basé sur Stuart Rossiter's réponse, mais nettoyer le code et les fichiers cachés correctement traitées:

import org.apache.commons.codec.digest.DigestUtils;
import java.io.*;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Vector;
public class Hashing
{
public static String hashDirectory(String directoryPath, boolean includeHiddenFiles) throws IOException
{
File directory = new File(directoryPath);
if (!directory.isDirectory())
{
throw new IllegalArgumentException("Not a directory");
}
Vector<FileInputStream> fileStreams = new Vector<>();
collectFiles(directory, fileStreams, includeHiddenFiles);
try (SequenceInputStream sequenceInputStream = new SequenceInputStream(fileStreams.elements()))
{
return DigestUtils.md5Hex(sequenceInputStream);
}
}
private static void collectFiles(File directory,
List<FileInputStream> fileInputStreams,
boolean includeHiddenFiles) throws IOException
{
File[] files = directory.listFiles();
if (files != null)
{
Arrays.sort(files, Comparator.comparing(File::getName));
for (File file : files)
{
if (includeHiddenFiles || !Files.isHidden(file.toPath()))
{
if (file.isDirectory())
{
collectFiles(file, fileInputStreams, includeHiddenFiles);
} else
{
fileInputStreams.add(new FileInputStream(file));
}
}
}
}
}
}

OriginalL'auteur BullyWiiPlaza

0

Il n'est pas clair ce que signifie la somme md5 d'un répertoire. Vous voudrez peut-être la somme de contrôle du fichier d'inscription; vous pouvez la somme de contrôle de la liste des fichiers et leur contenu. Si vous êtes déjà en additionnant le fichier de données eux-mêmes, je vous suggère de vous spec une sans ambiguïté de la représentation pour une inscription à l'annuaire (attention pour les mauvais caractères dans les noms de fichiers), puis calculer et de hachage qui à chaque fois. Vous devez également tenir compte de la façon dont vous allez gérer les fichiers spéciaux (sockets, des tuyaux, des appareils et des liens symboliques dans le monde unix; NTFS a des flux de fichier et je crois que quelque chose de semblable à des liens symboliques).

OriginalL'auteur crazyscot

Vous devez vous connecter pour publier un commentaire.