¡Seguramente debe haber una manera de hacer esto fácilmente!

Probé las aplicaciones de línea de comandos de Linux como sha1sumy, md5sumpero parece que solo pueden calcular valores hash de archivos individuales y generar una lista de valores hash, uno para cada archivo.

Necesito generar un solo hash para todo el contenido de una carpeta (no solo los nombres de archivo).

Me gustaria hacer algo como

sha1sum /folder/of/stuff > singlehashvalue

Editar: para aclarar, mis archivos están en varios niveles en un árbol de directorios, no todos están en la misma carpeta raíz.

Una forma posible sería:

ruta sha1sum / a / carpeta / * | sha1sum

Si hay un árbol de directorios completo, probablemente sea mejor usar find y xargs. Un posible comando sería

buscar ruta / a / carpeta -type f -print0 | sort -z | xargs -0 sha1sum | sha1sum

Y, finalmente, si también necesitas tener en cuenta los permisos y directorios vacíos:

(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

Los argumentos de statharán que imprima el nombre del archivo, seguido de sus permisos octales. Los dos hallazgos se ejecutarán uno tras otro, lo que generará el doble de la cantidad de E / S del disco, el primero buscará todos los nombres de archivos y sumará el contenido, el segundo buscará todos los nombres de archivos y directorios, el nombre de impresión y el modo. La lista de "nombres de archivos y sumas de verificación", seguida de "nombres y directorios, con permisos", se agregará a la suma de verificación para obtener una suma de verificación más pequeña.

• Utilice una herramienta de detección de intrusiones en el sistema de archivos como asistente .

• hash una bola de alquitrán del directorio:

  tar cvf - /path/to/folder | sha1sum

• Codifique algo usted mismo, como el delineador de vatine :

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

Tu puedes hacer tar -c /path/to/folder | sha1sum

Si solo desea verificar si algo en la carpeta cambió, le recomiendo este:

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

Solo le dará un hash de la salida de ls, que contiene carpetas, subcarpetas, sus archivos, su marca de tiempo, tamaño y permisos. Prácticamente todo lo que necesitaría para determinar si algo ha cambiado.

Tenga en cuenta que este comando no generará hash para cada archivo, pero es por eso que debería ser más rápido que usar find.

Un enfoque sólido y limpio

• Primero lo primero, ¡no acapares la memoria disponible ! Hash un archivo en trozos en lugar de alimentar el archivo completo.
• Diferentes enfoques para diferentes necesidades / propósitos (todos los siguientes o elija lo que corresponda):
  • Hash solo el nombre de entrada de todas las entradas en el árbol del directorio
  • Hash el contenido del archivo de todas las entradas (dejando el meta como, el número de inodo, ctime, atime, mtime, size, etc., ya tienes la idea)
  • Para un enlace simbólico, su contenido es el nombre de referencia. Aplícalo o elige saltear
  • Siga o no siga (nombre resuelto) el enlace simbólico mientras realiza el hash del contenido de la entrada
  • Si es un directorio, su contenido son solo entradas de directorio. Mientras se atraviesa de forma recursiva, eventualmente se les aplicará un hash, pero ¿deberían los nombres de entrada de directorio de ese nivel tener hash para etiquetar este directorio? Útil en casos de uso donde se requiere el hash para identificar un cambio rápidamente sin tener que atravesar profundamente para hash el contenido. Un ejemplo sería el cambio de nombre de un archivo, pero el resto del contenido permanece igual y todos son archivos bastante grandes.
  • Maneja bien archivos grandes (de nuevo, cuidado con la RAM)
  • Manejar árboles de directorios muy profundos (tenga en cuenta los descriptores de archivos abiertos)
  • Manejar nombres de archivos no estándar
  • ¿Cómo proceder con archivos que son sockets, tuberías / FIFO, dispositivos de bloque, dispositivos de caracteres? ¿Debes picarlos también?
  • No actualice el tiempo de acceso de ninguna entrada mientras atraviesa porque esto será un efecto secundario y contraproducente (¿intuitivo?) Para ciertos casos de uso.

Esto es lo que tengo encima de mi cabeza, cualquiera que haya pasado algún tiempo trabajando en esto prácticamente habría captado otras trampas y casos de esquina.

Aquí hay una herramienta , muy liviana en memoria, que se ocupa de la mayoría de los casos, puede ser un poco tosca en los bordes, pero ha sido bastante útil.

Un ejemplo de uso y salida 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 fragmento de salida amigable para los humanos:

...
... //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 solo desea aplicar un hash al contenido de los archivos, ignorando los nombres de archivo, puede usar

cat $FILES | md5sum

Asegúrese de tener los archivos en el mismo orden al calcular el hash:

cat $(echo $FILES | sort) | md5sum

Pero no puede tener directorios en su lista de archivos.

Otra herramienta para lograrlo:

http://md5deep.sourceforge.net/

Como suena: como md5sum pero también recursivo, además de otras características.

Si se trata de un repositorio de git y desea ignorar cualquier archivo en .gitignore, es posible que desee utilizar esto:

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

Esto me está funcionando bien.

Hay un script de Python para eso:

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

Si cambia los nombres de un archivo sin cambiar su orden alfabético, el script hash no lo detectará. Pero, si cambia el orden de los archivos o el contenido de cualquier archivo, ejecutar el script le dará un hash diferente al anterior.

Tuve que registrarme en un directorio completo para ver los cambios de archivo.

Pero excluyendo, marcas de tiempo, propiedad de directorios.

El objetivo es obtener una suma idéntica en cualquier lugar, si los archivos son idénticos.

Incluyendo alojado en otras máquinas, sin importar nada menos los archivos, o un cambio en ellos.

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

Genera una lista de hash por archivo, luego concatena esos hash en uno.

Esto es mucho más rápido que el método tar.

Para una mayor privacidad en nuestros hashes, podemos usar sha512sum en la misma receta.

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

Los hash también son idénticos en cualquier lugar con sha512sum, pero no se conoce una forma de revertirlo.

Intenta hacerlo en dos pasos:

1. crear un archivo con hashes para todos los archivos en una carpeta
2. hash este archivo

Al igual que:

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

O hazlo todo a la vez:

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

Canalizaría los resultados para archivos individuales sort(para evitar una mera reordenación de archivos para cambiar el hash) en md5sumo sha1sum, lo que elija.

Escribí un script de Groovy para hacer esto:

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

Puede personalizar el uso para evitar imprimir cada archivo, cambiar el resumen del mensaje, eliminar el hash del directorio, etc. Lo he probado con los datos de prueba del NIST y funciona como se esperaba. 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

Podría sha1sumgenerar la lista de valores hash y luego sha1sumesa lista nuevamente, depende de qué es exactamente lo que desea lograr.

Aquí hay una variante simple y corta en Python 3 que funciona bien para archivos de pequeño tamaño (por ejemplo, un árbol de fuentes o algo, donde cada archivo individualmente puede caber en la RAM fácilmente), ignorando los directorios vacíos, según las ideas de las otras soluciones:

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()                          

Funciona así:

1. Encuentre todos los archivos en el directorio de forma recursiva y ordénelos por nombre
2. Calcule el hash (predeterminado: SHA-1) de cada archivo (lee el archivo completo en la memoria)
3. Haga un índice textual con líneas "filename = hash"
4. Codifique ese índice de nuevo en una cadena de bytes UTF-8 y hash que

Puede pasar una función hash diferente como segundo parámetro si SHA-1 no es su taza de té.

Hasta ahora, la forma más rápida de hacerlo sigue siendo con alquitrán. Y con varios parámetros adicionales también podemos deshacernos de la diferencia causada por los metadatos.

Para usar tar para hash en el directorio, es necesario asegurarse de ordenar la ruta durante tar, de lo contrario, siempre es diferente.

tar -C <root-dir> -cf - --sort=name <dir> | sha256sum

ignorar el tiempo

Si no le importa el tiempo de acceso o modificar el tiempo, también use algo como --mtime='UTC 2019-01-01' para asegurarse de que todas las marcas de tiempo sean iguales.

ignorar la propiedad

Por lo general, necesitamos agregar --group=0 --owner=0 --numeric-ownerpara unificar los metadatos del propietario.

ignorar algunos archivos

utilizar --exclude=PATTERN