sha1sum ./path/to/directory/* | sha1sum 

lo anterior se publicó como una forma de calcular una suma de un directorio que contiene archivos. Este comando falla si el directorio incluye más directorios. ¿Hay alguna manera de calcular de forma recursiva el sha1sum de un directorio de directorios de manera universal (sin ajustar un algoritmo personalizado al directorio particular en cuestión)?

Gracias a este post SO -

find . -type f \( -exec sha1sum "$PWD"/{} \; \) | sha1sum

Advertencia: ¡Este código no ha sido probado ! Edite esta pregunta si está mal y puede solucionarlo; Aprobaré tu edición.

Generalmente me gusta el patrón "encontrar | xargs", así:

find ./path/to/directory/ -type f -print0  | xargs -0 sha1sum

Debe usar "-print0" y "-0", en caso de que haya espacios en los nombres de archivo.

Sin embargo, esto es muy similar al patrón "find -exec cmd {}".

Vea una discusión que compara los dos patrones aquí: https://stackoverflow.com/questions/896808/find-exec-cmd-vs-xargs

ACTUALIZACIÓN: Han pasado algunos años desde que publiqué esta respuesta y, mientras tanto, reescribí y mejoré el guión que presenté aquí varias veces. He decidido volver a publicar el nuevo script como una respuesta completamente nueva. Lo recomendaría mucho sobre este.

INTRODUCCIÓN

Observé que el orden en que el comando find genera los elementos encontrados dentro de un directorio varía dentro de directorios idénticos en diferentes particiones. Si está comparando los hashes del mismo directorio, no tiene que preocuparse por eso, pero si obtiene los hashes para asegurarse de que no se pierdan ni corrompan archivos durante una copia, debe incluir una línea adicional para ordenando el contenido del directorio y sus elementos. Por ejemplo, la respuesta de Matthew Bohnsack es bastante elegante:

find ./path/to/directory/ -type f -print0  | xargs -0 sha1sum

Pero si lo está usando para comparar un directorio copiado con su original, enviaría la salida a un archivo txt que compararía con la lista de salida del otro directorio usando Kompare o WinMerge o simplemente obteniendo los hashes de cada lista . La cuestión es que, como el orden en que la herramienta de búsqueda generará el contenido puede variar de un directorio a otro, Kompare señalará muchas diferencias porque los hash no se calcularon en el mismo orden. No es un gran problema para los directorios pequeños, pero es bastante molesto si se trata de 30000 archivos. Por lo tanto, debe realizar los pasos adicionales de ordenar la salida para facilitar la comparación de las listas hash entre los dos directorios.

find ./path/to/directory/ -type f -print0  | xargs -0 sha1sum > sha1sum_list_unsorted.txt
sort sha1sum_list_unsorted.txt > sha1sum_list_sorted.txt

Esto ordenaría la salida de modo que los archivos con el mismo hash vayan a estar en las mismas líneas cuando se ejecute el programa de diferenciación (siempre que no falten archivos en el nuevo directorio).

Y EN EL ESCRITO ...

Aquí hay un guión que escribí. Hace lo mismo que hace la respuesta find / xarg, pero ordenará los archivos antes de obtener el sha1sum (manteniéndolos en el mismo directorio). La primera línea del script encuentra todos los archivos dentro del directorio de forma recursiva. El siguiente ordena los resultados alfabéticamente. Los siguientes dos, toman el contenido ordenado y agregan un sha1sum y comillas a los archivos en la lista ordenada, creando un gran script de shell que calcula cada hash de los archivos, uno a la vez y lo envía a content_sha1sum.txt.

#!/bin/bash
find . -type f > content.txt
sort content.txt > content_sorted.txt
awk '{print "sha1sum \""$0}' content_sorted.txt > temp.txt
awk '{print $0"\""}' temp.txt > get_sha1.sh
chmod +x get_sha1.sh
./get_sha1.sh > content_sha1sum.txt
rm content.txt
rm content_sorted.txt
rm temp.txt
rm get_sha1.sh
xdg-open content_sha1sum.txt

Espero que esto ayude.

INTRODUCCIÓN

Hace unos años, escribí y presenté (en este mismo hilo) un script que puede verificar las firmas hash de todos los archivos individuales en la estructura del directorio actual y mostrarlo como una lista en un archivo de texto.

Desde entonces, he refinado esta fórmula varias veces. He decidido volver a publicar mi script nuevo y mejorado aquí como una respuesta separada. Está escrito para sha256, pero cualquiera que quiera usar sha1 puede hacer una búsqueda simple y reemplazar en gedit para intercambiar sha256 con sha1. Personalmente, no he usado sha1 durante un par de años y no lo recomendaría, ya que está obsoleto y Google ha demostrado cómo puede verse comprometido .

Esto es lo que hace mi nuevo script:

1. Simplemente puede usar el script yendo al directorio que desea hacer hash e ingresando:

   sha256rec

   Alternativamente, puede llamar a este script desde otro directorio haciendo:

   sha256rec "/path/to/target/directory/you/want/hash"

2. El script detectará si tiene privilegios de escritura en el directorio actual. Si lo hace, los resultados se guardarán en el directorio actual. Si no tiene privilegios de escritura o si su directorio actual está en un sistema de solo lectura (como un cdrom), los resultados se guardarán en el directorio de inicio del usuario actual.

3. El script detectará si algunos de los subdirectorios no son accesibles con los privilegios actuales del usuario. Si todos son legibles, entonces no se produce la elevación de privilegios, si no lo son, los privilegios del usuario se elevan a root.

4. Buscar se utiliza para buscar todos los archivos en la estructura de directorios actual (incluidos todos los subdirectorios). Ordenar se utiliza para asegurarse de que los resultados se emiten alfabéticamente. La lista resultante se somete a sha256sum y se envía a un archivo de texto.

5. Desde que escribí el antiguo script, adopté una filosofía de diseño de que los archivos temporales son malos y deben evitarse cuando sea posible, ya que dejan a los usuarios abiertos a la intromisión y manipulación por parte de terceros maliciosos. Por lo tanto, todos los datos de este nuevo script se manipulan como variables hasta el último minuto, donde los resultados se superan como un archivo de texto.

6. El archivo resultante en sí es hash y la ruta / hash se supera en el terminal. Me gusta tomar fotos de estos hashes con una cámara fuera de línea de la vieja escuela para asegurarme de que el archivo de resultados no haya sido alterado cuando lo consulte más adelante.

7. Los archivos de resultados antiguos se ignoran en el recuento. Facilita la comparación de resultados.

Aquí hay un ejemplo de la salida del terminal cuando ejecuto mi script:

kernelcrunch@ubuntu:/usr/src/linux-headers-4.13.0-16-generic$ sha256rec
======================================================================= 
sha256rec:         
=======================================================================        
Current Folder : /usr/src/linux-headers-4.13.0-16-generic   
Target Folder  : /usr/src/linux-headers-4.13.0-16-generic
Output File    : /home/kernelcrunch/000_sha256sum_recurs_linux-headers-4.13.0-16-generic_d_22-04-2018_t_02.17.txt


Seems you're currently in either a Read-Only system or a root owned directory as a regular user. You can find the hash results in your home folder.
f3ddb06212622c375c6bcc11bd629ce38f6c48b7474054ca6f569ded4b4af9d8  /home/kernelcrunch/000_sha256sum_recurs_linux-headers-4.13.0-16-generic_d_22-04-2018_t_02.17.txt
Operation Length: 10 Seconds.
=======================================================================
kernelcrunch@ubuntu:/usr/src/linux-headers-4.13.0-16-generic$ 

Aquí hay un fragmento de la salida que se puede encontrar en 000_sha256sum_recurs_linux-headers-4.13.0-16-generic_d_22-04-2018_t_02.17.txt:

79c3f378a42bd225642220cc1e4801deb35c046475bb069a96870ad773082805  ./.9491.d
2e336c69cde866c6f01a3495048d0ebc2871dd9c4cb5d647be029e0205d15ce6  ./.config
174f23ff7a7fba897bfb7cf17e9a501bcecacf7ef0c0d5cf030414c1e257d4e3  ./.config.old
389d83f546b250304a9a01bb3072ff79f9d9e380c8a2106cadbf714a872afe33  ./.missing-syscalls.d
035dc77da819101cb9889b4e515023dddd2c953f00d2653b87c6196a6560903e  ./Module.symvers
b28054d7995233e6d003ceb9ed119a0b3354f5ccf77b8d687fc0353ae3c5bfb8  ./arch/x86/include/generated/asm/.syscalls_32.h.cmd
01cf821170e3e6e592e36a96e8628377151c762ac2ee3210c96004bfaef22f5f  ./arch/x86/include/generated/asm/.syscalls_64.h.cmd
111efa83187c58a74a9b0170fd496b497b0682d109a7c240c17e2ffcc734f4f4  ./arch/x86/include/generated/asm/.unistd_32_ia32.h.cmd
fcba4e8abf9e95472c31708555db844ac43c87260fb0ba706b6f519404bf9aba  ./arch/x86/include/generated/asm/.unistd_64_x32.h.cmd
3264438a54cbf7e62b05d38a93c5df8fe4202ac782a5d83ed202cba9eee71139  ./arch/x86/include/generated/asm/.xen-hypercalls.h.cmd
4bd7a45837da7de379b87242efe562ce06bf9d8ab8f636c205bb5ef384c8f759  ./arch/x86/include/generated/asm/clkdev.h
0d96461abd23bbf2da522822948455413a345f9ef8ac7a7f81c6126584b3c964  ./arch/x86/include/generated/asm/dma-contiguous.h
b1a54c24a12ce2c0f283661121974436cdb09ae91822497458072f5f97447c5d  ./arch/x86/include/generated/asm/early_ioremap.h
dd864107295503e102ea339e0fd4496204c697bdd5c1b1a35864dfefe504a990  ./arch/x86/include/generated/asm/mcs_spinlock.h
782ce66804d000472b3c601978fa9bd98dcf3b2750d608c684dc52dd1aa0eb7e  ./arch/x86/include/generated/asm/mm-arch-hooks.h
cd9913197f90cd06e55b19be1e02746655b5e52e388f13ec29032294c2f75897  ./arch/x86/include/generated/asm/syscalls_32.h
758ce35908e8cfeec956f57a206d8064a83a49298e47d47b7e9a7d37b5d96d59  ./arch/x86/include/generated/asm/syscalls_64.h
1147ca3a8443d9ccbdf9cd1f4b9b633f0b77f0559b83ec5e4fa594eadb2548be  ./arch/x86/include/generated/asm/unistd_32_ia32.h
ca5223fbf8f03613a6b000e20eb275d9b8081c8059bc540481a303ce722d42f3  ./arch/x86/include/generated/asm/unistd_64_x32.h
31703052c0d2ab8fe14b4e5dfcc45fcbd5feb5016b0a729b6ba92caa52b069e2  ./arch/x86/include/generated/asm/xen-hypercalls.h
c085ff1b6e9d06faa3fc6a55f69f9065c54098d206827deec7fe0a59d316fc99  ./arch/x86/include/generated/uapi/asm/.unistd_32.h.cmd
7929c16d349845cebb9e303e0ff15f67d924cac42940d0f7271584f1346635fc  ./arch/x86/include/generated/uapi/asm/.unistd_64.h.cmd
9aa492c5a75f5547f8d1dc454bef78189b8f262d1c4b00323a577907f138a63e  ./arch/x86/include/generated/uapi/asm/.unistd_x32.h.cmd
f568e151bbbb5d51fd531604a4a5ca9f17004142cd38ce019f0d5c661d32e36b  ./arch/x86/include/generated/uapi/asm/unistd_32.h
c45cf378498aa06b808bb9ccf5c3c4518e26501667f06c907a385671c60f14ae  ./arch/x86/include/generated/uapi/asm/unistd_64.h
a0088d8d86d7fd96798faa32aa427ed87743d3a0db76605b153d5124845161e2  ./arch/x86/include/generated/uapi/asm/unistd_x32.h
e757eb6420dffa6b24b7aa38ca57e6d6f0bfa7d6f3ea23bbc08789c7e31d15fa  ./arch/x86/kernel/.asm-offsets.s.cmd
f9e703e4f148d370d445c2f8c95f4a1b1ccde28c149cff2db5067c949a63d542  ./arch/x86/kernel/asm-offsets.s
7971fb3e0cc3a3564302b9a3e1ad188d2a00b653189968bbc155d42c70ce6fbf  ./arch/x86/purgatory/.entry64.o.cmd
8352d79fe81d2cf694880f428e283d79fd4b498cea5a425644da25a9641be26b  ./arch/x86/purgatory/.kexec-purgatory.c.cmd
37f3edbee777e955ba3b402098cb6c07500cf9dc7e1d44737f772ac222e6eb3e  ./arch/x86/purgatory/.purgatory.o.cmd
bb8b895cbd2611b69e2f46c2565b4c2e63a85afb56cff946a555f2d277ee99b2  ./arch/x86/purgatory/.purgatory.ro.cmd
bcc2365c9d3d027f1469806eb4f77b0f3ede6eb0855ea0fcd28aa65884046a54  ./arch/x86/purgatory/.setup-x86_64.o.cmd
872229f334fdcc8562e31b9f6581008c1571ac91f12889cd0ff413590585155a  ./arch/x86/purgatory/.sha256.o.cmd
6fb0cbef120aadee282f7bc3b5ea2f912980f16712281f8f7b65901005194422  ./arch/x86/purgatory/.stack.o.cmd
cd1b61063ae3cf45ee0c58b2c55039f3eac5f67a5154726d288b4708c4d43deb  ./arch/x86/purgatory/.string.o.cmd
e5826f0216fd590972bbc8162dd175f87f9f7140c8101505d8ca5849c850ec91  ./arch/x86/purgatory/entry64.o

(continúa con otras 7000+ líneas como esta, pero se entiende la idea)

INSTALACIÓN

1. Abra una terminal e ingrese los siguientes comandos:

   cd /usr/bin
   sudo su
   echo '#!/bin/bash'> /usr/bin/sha256rec
   chmod +x /usr/bin/sha256rec
   touch /usr/bin/sha256rec
   nano /usr/bin/sha256rec

2. En nano, use Shif + Ctrl + v para pegar. Ctrl-O e Enter para guardar. Ctr-X sale. Pegue mi script allí:

(pegar después de #! / bin / bash)

  #FUNCTIONS OR FUNCTYOU?
  function s_readonly { err=$(date +%s%N); cd "$1"; mkdir $err 2> /tmp/$err; rmdir $err 2>/dev/null; echo $(cat /tmp/$err|grep -i "Read-only file system"|wc -l);shred -n 0 -uz /tmp/$err; }
  function w_denied { echo $(err=$(date +%s%N); cd "$1"; mkdir $err 2> /tmp/$err; rmdir $err 2>/dev/null; cat /tmp/$err|grep -i "Permission denied"|wc -l;shred -n 0 -uz /tmp/$err); }
  function r_denied { echo $(err=$(date +%s%N); cd "$1" >/dev/null 2> /tmp/$err; find . >/dev/null 2>> /tmp/$err; cat /tmp/$err|grep -i "Permission denied"|wc -l;shred -n 0 -uz /tmp/$err); }
  function rando_name { rando=$(echo $(date +%s%N)|sha256sum|awk '{print $1}'); rando=${rando::$(shuf -i 30-77 -n 1)}; echo $rando;}
  function ms0 { ms0=$(($(date +%s%N)/1000000)); }; function mstot { echo $(($(($(date +%s%N)/1000000))-$ms0));}
  function s0 { s0=$(date +%s); }; function stot { echo $(($(date +%s)-$s0));}
  s0

  #CHECK IF A TARGET DIR WAS SPECIFIED (-t= or --target= switch)
  if [ ! -z "$1" ]; then arg1="$1"; arg1_3=${arg1::3}; arg1_9=${arg1::9};fi
  if [ "$arg1_3" = "-t=" -o "$arg1_9" = "--target=" ]; then 
    switch=$(echo $arg1|awk -F '=' '{print $1}')
    switch_chr=$((${#switch}+1))
    target=${arg1:$switch_chr}
    current=$(pwd)
    cd "$target"
    arg1="" #<- cancels the not path in the find line
  else
    current=$(pwd)
    target=$(pwd) 
  fi

  echo -e  "=======================================================================\
    \nsha256rec: \
          \n=======================================================================\
          \nCurrent Folder : $current \
    \nTarget Folder  : $target"

  #GETS DEFAULT_USER, ASSUME'S YOU'RE USER 1000, IF 1000 DOESN'T EXIST SEARCHES 999, THEN 1001, 1002
  default_user=$(awk -v val=1000 -F ":" '$3==val{print $1}' /etc/passwd)
  if [ -z "$default_user" ]; then default_user=$(awk -v val=999 -F ":" '$3==val{print $1}' /etc/passwd); fi
  if [ -z "$default_user" ]; then default_user=$(awk -v val=1001 -F ":" '$3==val{print $1}' /etc/passwd); fi
  if [ -z "$default_user" ]; then default_user=$(awk -v val=1002 -F ":" '$3==val{print $1}' /etc/passwd); fi

  if [ "$(users | wc -l)" = "1" ]; then USER=$(users|awk '{print $1}'); else USER=$default_user;fi #not perfect but meh...

  #running rando_name in this very specific spot between USER detection and Permission detection, some interfers somehow with detection functions... 
  #the rando function placed underneath the user detection is somehow turning c=$current from the dir path to whatever rando_name puts out.

  #FIGURE OUT WHERE TO PUT HASH LIST
  hash_file="000_sha256sum_recurs_${target##*/}_d_$(date +%d-%m-20%y)_t_$(date +%H.%M).txt"
  if [ $(s_readonly "$current") -gt 0 -o $(w_denied "$current") -gt 0 ]; then if [ "$(whoami)" != root ]; then dest="/home/$(whoami)";echo -e "Output File    : $dest/$hash_file\n\n";echo "Seems you're currently in either a Read-Only system or a root owned directory as a regular user. You can find the hash results in your home folder."; else dest="/home/$USER";echo -e "Output File    : $dest/$hash_file\n\n";echo "Seems you're currently a Read-Only system. You can find the hash results in $USER's home folder.";fi; else dest="$current";echo -e "Output File    : $dest/$hash_file\n\n";echo "Results will be saved here.";fi



  #CAN REGULAR USER ACCESS TARGET DIR? ARE ALL IT'S SUBDIRS READABLE?
  if [ $(r_denied "$target") -gt 0 ]; then sudo=sudo; echo "Some folder were not read-able as a regular user. User elevation will be required.";fi

  #PERFORM RECURSIVE HASHING
  command=$($sudo find . -type f -not -type l -not -path "$arg1"  -not -path "$2"  -not -path "$3" -not -path "$4"  -not -path "$5"  -not -path "$6" -not -path "$7"  -not -path "$8"  -not -path "$9" |grep -v "\./000_sha"|sort|awk "{print \"$sudo sha256sum \\\"\"\$0}"|awk '{print $0"\""}'|tr '\n' ';')
  eval $command > "$dest/$hash_file"

  sha256sum "$dest/$hash_file"
  echo "Operation Length: $(stot) Seconds."
  echo -e  "======================================================================="



  if [ "$target" != "$current" ]; then cd "$current";fi


  exit
  #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
  #||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

3. Cuando salga de nano, asegúrese de salir del estado elevado ingresando:

   exit

PENSAMIENTOS FINALES

1. Esto solo funcionará si tiene instalado bash. He usado algunos Synthax para la manipulación de subcadenas que no funcionan con sh, dash, ksh o zsh. Todavía puede usar cualquiera de los otros shells como controladores diarios, pero es necesario instalar bash.

2. Las listas de salida se pueden comparar con una variedad de herramientas como: (en el terminal) diff, sdiff (y gráfico) difuso, kdiff, winmerge.

3. Mi archivo ordena la salida en función de la ruta, para que sea más fácil de leer por los humanos. He notado que el comando de clasificación funciona de manera diferente en diferentes distribuciones. Por ejemplo, en una distribución, las letras de MAYÚSCULAS tenían prioridad sobre las no mayúsculas y en la otra no. Esto afecta el orden de las líneas de los archivos de salida y podría dificultar la comparación de los archivos. Esto no debería presentar ningún problema si siempre usa el script en la misma distribución, pero puede hacerlo si se generaron listas hash en dos entornos diferentes. Esto se soluciona fácilmente clasificando los archivos hash una vez más para que las líneas se ordenen por hash en lugar de ruta:

    cat 000_sha256sum_oldhashlist|sort> ./old
    cat 000_sha256sum_newhashlist|sort> ./new
    sha256sum ./old ./new; diff ./old ./new

Esto parece funcionar para mí:

find . \( -not -name . \) -type f -exec cat {} + | sha1sum

EDITAR: esto solo mostrará todos los archivos contenidos en el árbol de directorios. Si se cambiara el nombre de un directorio, esto no lo detectaría. Tal vez algo como:

find . -exec sha1sum {} + 2>&1 | sha1sum

Lo haría. Aunque casi la misma respuesta que la otra

Otro truco podría ser usar tar para trocear los contenidos y metadatos del archivo:

tar -cf - ./path/to/directory | sha1sum

Solución rápida, robusta y portátil.

A diferencia de algunas de las otras soluciones involucradas tar, la siguiente solución funciona en cualquier máquina que tenga las utilidades estándar de Unix, y es más rápida que todas las demás soluciones al paralelizar la suma de comprobación:

find . -type f | xargs -d'\n' -P0 -n1 md5sum | sort -k 2 | md5sum

Como utiliza una ordenación al final, no hay progreso en tiempo real, así que solo deje que se ejecute el comando.

Esto es lo que hacen los argumentos:

• find . -type f encuentra todos los archivos en el directorio actual y sus subdirectorios
• xargs -d'\n'divide la salida de find en líneas (si espera tener archivos con nuevas líneas, entonces haga lo habitual find -print0 | xargs -0)
• -P0 n1se ejecuta md5sumen procesos paralelos, utilizando el número máximo de procesos admitidos por la máquina (¡multi-núcleo!)
• sort -k 2ordena por el segundo campo de la md5sumsalida, que es la ruta completa a cada archivo (el primero es el MD5)
• el final md5sumcalcula una suma de comprobación de la lista de sumas de comprobación de archivos, de modo que obtiene una suma de comprobación del directorio completo en una línea, que puede comparar fácilmente visualmente en las ventanas de terminal

Antes de decir que "MD5 ha sido comprometido", recuerde cuál es su modelo de amenaza. ¿Está tratando de asegurarse de que los archivos que copió de algún otro host o disco llegaron intactos? Entonces MD5 es más que suficiente, porque las posibilidades de que un archivo se corrompa en tránsito pero tenga el mismo MD5 son cero. Pero si tiene miedo de que un atacante tenga tiempo para reemplazar un archivo por otro diferente con una suma de verificación colisionante, entonces úselo sha256sum. La desventaja es que las funciones SHA son más lentas que MD5 .

Progreso detallado en tiempo real

Finalmente, si desea ver el progreso en tiempo real, modifique la canalización para usar un archivo temporal para las sumas de verificación:

find . -type f | xargs -d\\n -P0 -n1 md5sum | tee /tmp/sums && sort -k 2 /tmp/sums | md5sum

(Tenga en cuenta que mover el sortderecho después findno funcionaría, ya que xargs -P0paraleliza md5sumy los resultados pueden llegar fuera de orden)

Esta versión del comando también le permite diferenciar los dos /tmp/sumsarchivos (asegúrese de cambiar el nombre del segundo si está en la misma máquina) y ver qué archivos difieren.

En lugar de tener UN archivo enorme que contiene toda la información hash, estaba buscando una manera de hacer un archivo en cada carpeta de un árbol. Me inspiré en los comentarios aquí. El mío es un poco más complejo de lo que se publica aquí. Uso la rotación de archivos, pero este es el menos complejo para los nuevos jugadores. Esta versión tendrá que sobrescribir las sumas de cheques antiguas con las nuevas. Puede ser bueno mantener 2-3 versiones dependiendo de la frecuencia con la que lo ejecute y su necesidad de 'profundidad'.

[usuario @ host bin] $ cat mkshaindir 
#! / bin / dash
cd $ 1
sha512sum *> .sha512sum

[usuario @ host bin] $ find / var / tmp -type d -print0 | xargs -0 -i mkshaindir {}

Tenga en cuenta que mkshaindir, para mis propósitos, es un componente separado porque es posible que necesite crear un hash de archivos en una nueva carpeta, o de uno que se modificó recientemente. Todo esto se puede combinar en un script si es necesario.

El resto se deja como ejercicio para el lector.

basado en la respuesta anterior :

find ./path/to/directory -print0 | LC_ALL=C sort --zero-terminated | tar --create --no-recursion --null --files-from /dev/stdin --file /dev/stdout --verbose --numeric-owner | sha1sum

• tipo estable
• propietario numérico e identificación del grupo
• progreso detallado
• nombre de archivo seguro

@allquixoticLa respuesta no genera los mismos hashes en diferentes máquinas que no nos ayudarán a verificar y tener hashes consistentes.

La siguiente línea find . -type f \( -exec md5sum "$PWD"/{} \; \)devuelve el siguiente resultado:

d41d8cd98f00b204e9800998ecf8427e  /home/helloWorld.c
24811012be8faa36c8f487bbaaadeb71  /home/helloMars.c

Por lo tanto, el camino sería diferente en diferentes máquinas. awk '{print $1}'nos ayudará a obtener la primera columna, que solo tiene el hash de los archivos. Más tarde, debemos ordenar esos hashes, donde el orden puede ser diferente en diferentes máquinas, lo que también puede hacer que tengamos diferentes hashes si hay más de dos archivos.

Solución:

Para Mac:

find ./path/to/directory/ -type f \( -exec md5 -q  "$PWD"/{} \; \) | awk '{print $1}' | sort | md5

Para Linux:

find ./path/to/directory/ -type f \( -exec md5sum "$PWD"/{} \; \) | awk '{print $1}' | sort | md5sum | awk '{print $1}'