Il doit sûrement y avoir un moyen de le faire facilement!

J'ai essayé les applications de ligne de commande Linux telles que sha1sumet, md5summais elles ne semblent pouvoir calculer que les hachages de fichiers individuels et afficher une liste de valeurs de hachage, une pour chaque fichier.

J'ai besoin de générer un seul hachage pour tout le contenu d'un dossier (pas seulement les noms de fichiers).

J'aimerais faire quelque chose comme

sha1sum /folder/of/stuff > singlehashvalue

Edit: pour clarifier, mes fichiers sont à plusieurs niveaux dans une arborescence de répertoires, ils ne sont pas tous assis dans le même dossier racine.

Une solution possible serait:

sha1sum chemin / vers / dossier / * | sha1sum

S'il existe toute une arborescence de répertoires, il vaut probablement mieux utiliser find et xargs. Une commande possible serait

trouver chemin / vers / dossier -type f -print0 | sort -z | xargs -0 sha1sum | sha1sum

Et, enfin, si vous devez également tenir compte des permissions et des répertoires vides:

(find path/to/folder -type f -print0  | sort -z | xargs -0 sha1sum;
 find path/to/folder \( -type f -o -type d \) -print0 | sort -z | \
   xargs -0 stat -c '%n %a') \
| sha1sum

Les arguments de le statferont afficher le nom du fichier, suivi de ses autorisations octales. Les deux recherches s'exécuteront l'une après l'autre, provoquant le double de la quantité d'E / S disque, la première trouvant tous les noms de fichiers et la somme de contrôle du contenu, la seconde trouvant tous les noms de fichiers et de répertoires, imprimant le nom et le mode. La liste des "noms de fichiers et sommes de contrôle", suivie de "noms et répertoires, avec permissions" sera alors additionnée, pour une somme de contrôle plus petite.

• Utilisez un outil de détection d'intrusion dans le système de fichiers comme l' aide .

• hacher une boule tar du répertoire:

  tar cvf - /path/to/folder | sha1sum

• Codez quelque chose vous-même, comme oneliner de vatine :

  find /path/to/folder -type f -print0 | sort -z | xargs -0 sha1sum | sha1sum

Tu peux faire tar -c /path/to/folder | sha1sum

Si vous voulez juste vérifier si quelque chose dans le dossier a changé, je vous recommande celui-ci:

ls -alR --full-time /folder/of/stuff | sha1sum

Il vous donnera simplement un hachage de la sortie ls, qui contient les dossiers, les sous-dossiers, leurs fichiers, leur horodatage, leur taille et leurs autorisations. À peu près tout ce dont vous auriez besoin pour déterminer si quelque chose a changé.

Veuillez noter que cette commande ne générera pas de hachage pour chaque fichier, mais c'est pourquoi elle devrait être plus rapide que d'utiliser find.

Une approche robuste et propre

• Tout d'abord, ne monopolisez pas la mémoire disponible ! Hash un fichier en morceaux plutôt que d'alimenter le fichier entier.
• Différentes approches pour différents besoins / objectifs (tout ce qui suit ou choisissez ce qui s'applique jamais):
  • Hash uniquement le nom d'entrée de toutes les entrées de l'arborescence de répertoires
  • Hash le contenu du fichier de toutes les entrées (en laissant le méta comme, le numéro d'inode, ctime, atime, mtime, size, etc., vous avez l'idée)
  • Pour un lien symbolique, son contenu est le nom référent. Hachez-le ou choisissez de l'ignorer
  • Suivre ou ne pas suivre (nom résolu) le lien symbolique lors du hachage du contenu de l'entrée
  • S'il s'agit d'un répertoire, son contenu n'est que des entrées de répertoire. Lors de la traversée récursive, ils seront éventuellement hachés mais les noms des entrées de répertoire de ce niveau doivent-ils être hachés pour marquer ce répertoire? Utile dans les cas d'utilisation où le hachage est nécessaire pour identifier rapidement un changement sans avoir à parcourir en profondeur pour hacher le contenu. Un exemple serait le changement de nom d'un fichier mais le reste du contenu reste le même et ce sont tous des fichiers assez volumineux
  • Gérez bien les fichiers volumineux (encore une fois, faites attention à la RAM)
  • Gérez des arborescences de répertoires très profondes (faites attention aux descripteurs de fichiers ouverts)
  • Gérer les noms de fichiers non standard
  • Comment procéder avec des fichiers qui sont des sockets, des tubes / FIFO, des périphériques bloc, des périphériques char? Faut-il les hacher aussi?
  • Ne mettez à jour le temps d'accès d'aucune entrée pendant la traversée car ce sera un effet secondaire et contre-productif (intuitif?) Pour certains cas d'utilisation.

C'est ce que j'ai sur la tête, quiconque a passé du temps à travailler là-dessus aurait pratiquement attrapé d'autres pièges et cas de coin.

Voici un outil , très léger sur la mémoire, qui traite la plupart des cas, peut être un peu rugueux sur les bords mais a été très utile.

Un exemple d'utilisation et de sortie de dtreetrawl.

Usage:
  dtreetrawl [OPTION...] "/trawl/me" [path2,...]

Help Options:
  -h, --help                Show help options

Application Options:
  -t, --terse               Produce a terse output; parsable.
  -j, --json                Output as JSON
  -d, --delim=:             Character or string delimiter/separator for terse output(default ':')
  -l, --max-level=N         Do not traverse tree beyond N level(s)
  --hash                    Enable hashing(default is MD5).
  -c, --checksum=md5        Valid hashing algorithms: md5, sha1, sha256, sha512.
  -R, --only-root-hash      Output only the root hash. Blank line if --hash is not set
  -N, --no-name-hash        Exclude path name while calculating the root checksum
  -F, --no-content-hash     Do not hash the contents of the file
  -s, --hash-symlink        Include symbolic links' referent name while calculating the root checksum
  -e, --hash-dirent         Include hash of directory entries while calculating root checksum

Un extrait de sortie conviviale:

...
... //clipped
...
/home/lab/linux-4.14-rc8/CREDITS
        Base name                    : CREDITS
        Level                        : 1
        Type                         : regular file
        Referent name                :
        File size                    : 98443 bytes
        I-node number                : 290850
        No. directory entries        : 0
        Permission (octal)           : 0644
        Link count                   : 1
        Ownership                    : UID=0, GID=0
        Preferred I/O block size     : 4096 bytes
        Blocks allocated             : 200
        Last status change           : Tue, 21 Nov 17 21:28:18 +0530
        Last file access             : Thu, 28 Dec 17 00:53:27 +0530
        Last file modification       : Tue, 21 Nov 17 21:28:18 +0530
        Hash                         : 9f0312d130016d103aa5fc9d16a2437e

Stats for /home/lab/linux-4.14-rc8:
        Elapsed time     : 1.305767 s
        Start time       : Sun, 07 Jan 18 03:42:39 +0530
        Root hash        : 434e93111ad6f9335bb4954bc8f4eca4
        Hash type        : md5
        Depth            : 8
        Total,
                size           : 66850916 bytes
                entries        : 12484
                directories    : 763
                regular files  : 11715
                symlinks       : 6
                block devices  : 0
                char devices   : 0
                sockets        : 0
                FIFOs/pipes    : 0

Si vous souhaitez simplement hacher le contenu des fichiers, en ignorant les noms de fichiers, vous pouvez utiliser

cat $FILES | md5sum

Assurez-vous que les fichiers sont dans le même ordre lors du calcul du hachage:

cat $(echo $FILES | sort) | md5sum

Mais vous ne pouvez pas avoir de répertoires dans votre liste de fichiers.

Un autre outil pour y parvenir:

http://md5deep.sourceforge.net/

Tel quel: comme md5sum mais aussi récursif, ainsi que d'autres fonctionnalités.

S'il s'agit d'un référentiel git et que vous souhaitez ignorer tous les fichiers .gitignore, vous pouvez utiliser ceci:

git ls-files <your_directory> | xargs sha256sum | cut -d" " -f1 | sha256sum | cut -d" " -f1

Cela fonctionne bien pour moi.

Il existe un script python pour cela:

http://code.activestate.com/recipes/576973-getting-the-sha-1-or-md5-hash-of-a-directory/

Si vous modifiez les noms d'un fichier sans changer leur ordre alphabétique, le script de hachage ne le détectera pas. Mais, si vous modifiez l'ordre des fichiers ou le contenu d'un fichier, l'exécution du script vous donnera un hachage différent de celui d'avant.

Essayez de le faire en deux étapes:

1. créer un fichier avec des hachages pour tous les fichiers d'un dossier
2. hacher ce fichier

Ainsi:

# for FILE in `find /folder/of/stuff -type f | sort`; do sha1sum $FILE >> hashes; done
# sha1sum hashes

Ou faites tout cela en même temps:

# cat `find /folder/of/stuff -type f | sort` | sha1sum

Je dirigerais les résultats pour les fichiers individuels à travers sort(pour éviter une simple réorganisation des fichiers pour changer le hachage) dans md5sumou sha1sum, selon votre choix.

J'ai écrit un script Groovy pour faire ceci:

import java.security.MessageDigest

public static String generateDigest(File file, String digest, int paddedLength){
    MessageDigest md = MessageDigest.getInstance(digest)
    md.reset()
    def files = []
    def directories = []

    if(file.isDirectory()){
        file.eachFileRecurse(){sf ->
            if(sf.isFile()){
                files.add(sf)
            }
            else{
                directories.add(file.toURI().relativize(sf.toURI()).toString())
            }
        }
    }
    else if(file.isFile()){
        files.add(file)
    }

    files.sort({a, b -> return a.getAbsolutePath() <=> b.getAbsolutePath()})
    directories.sort()

    files.each(){f ->
        println file.toURI().relativize(f.toURI()).toString()
        f.withInputStream(){is ->
            byte[] buffer = new byte[8192]
            int read = 0
            while((read = is.read(buffer)) > 0){
                md.update(buffer, 0, read)
            }
        }
    }

    directories.each(){d ->
        println d
        md.update(d.getBytes())
    }

    byte[] digestBytes = md.digest()
    BigInteger bigInt = new BigInteger(1, digestBytes)
    return bigInt.toString(16).padLeft(paddedLength, '0')
}

println "\n${generateDigest(new File(args[0]), 'SHA-256', 64)}"

Vous pouvez personnaliser l'utilisation pour éviter d'imprimer chaque fichier, modifier le résumé du message, supprimer le hachage de répertoire, etc. Je l'ai testé par rapport aux données de test NIST et cela fonctionne comme prévu. http://www.nsrl.nist.gov/testdata/

gary-macbook:Scripts garypaduana$ groovy dirHash.groovy /Users/garypaduana/.config
.DS_Store
configstore/bower-github.yml
configstore/insight-bower.json
configstore/update-notifier-bower.json
filezilla/filezilla.xml
filezilla/layout.xml
filezilla/lockfile
filezilla/queue.sqlite3
filezilla/recentservers.xml
filezilla/sitemanager.xml
gtk-2.0/gtkfilechooser.ini
a/
configstore/
filezilla/
gtk-2.0/
lftp/
menus/
menus/applications-merged/

79de5e583734ca40ff651a3d9a54d106b52e94f1f8c2cd7133ca3bbddc0c6758

J'ai dû vérifier dans un répertoire entier pour les changements de fichiers.

Mais avec l'exclusion, les horodatages, la propriété des répertoires.

Le but est d'obtenir une somme identique n'importe où, si les fichiers sont identiques.

Y compris hébergé dans d'autres machines, indépendamment de tout sauf des fichiers, ou d'une modification de ceux-ci.

md5sum * | md5sum | cut -d' ' -f1

Il génère une liste de hachage par fichier, puis concatène ces hachages en un seul.

C'est bien plus rapide que la méthode tar.

Pour une plus grande confidentialité dans nos hachages, nous pouvons utiliser sha512sum sur la même recette.

sha512sum * | sha512sum | cut -d' ' -f1

Les hachages sont également identiques partout en utilisant sha512sum mais il n'y a aucun moyen connu de l'inverser.

Vous pouvez sha1sumgénérer la liste des valeurs de hachage, puis à sha1sumnouveau cette liste, cela dépend exactement de ce que vous voulez accomplir.

Voici une variante simple et courte de Python 3 qui fonctionne bien pour les fichiers de petite taille (par exemple, une arborescence source ou quelque chose, où chaque fichier individuellement peut facilement s'intégrer dans la RAM), en ignorant les répertoires vides, en fonction des idées des autres solutions:

import os, hashlib

def hash_for_directory(path, hashfunc=hashlib.sha1):                                                                                            
    filenames = sorted(os.path.join(dp, fn) for dp, _, fns in os.walk(path) for fn in fns)         
    index = '\n'.join('{}={}'.format(os.path.relpath(fn, path), hashfunc(open(fn, 'rb').read()).hexdigest()) for fn in filenames)               
    return hashfunc(index.encode('utf-8')).hexdigest()                          

Cela fonctionne comme ceci:

1. Trouvez tous les fichiers du répertoire de manière récursive et triez-les par nom
2. Calculer le hachage (par défaut: SHA-1) de chaque fichier (lit le fichier entier en mémoire)
3. Créer un index textuel avec des lignes "filename = hash"
4. Recodez cet index dans une chaîne d'octets UTF-8 et hachez

Vous pouvez passer une fonction de hachage différente comme deuxième paramètre si SHA-1 n'est pas votre tasse de thé.