Certamente deve haver uma maneira de fazer isso facilmente!

Eu tentei os aplicativos de linha de comando do Linux como sha1sume, md5summas eles parecem apenas ser capazes de calcular hashes de arquivos individuais e gerar uma lista de valores de hash, um para cada arquivo.

Preciso gerar um único hash para todo o conteúdo de uma pasta (não apenas os nomes dos arquivos).

Eu gostaria de fazer algo como

sha1sum /folder/of/stuff > singlehashvalue

Editar: para esclarecer, meus arquivos estão em vários níveis em uma árvore de diretório, eles não estão todos na mesma pasta raiz.

Uma maneira possível seria:

caminho sha1sum / para / pasta / * | sha1sum

Se houver uma árvore de diretórios inteira, é melhor você usar find e xargs. Um comando possível seria

localizar caminho / para / pasta -tipo f -print0 | sort -z | xargs -0 sha1sum | sha1sum

E, finalmente, se você também precisa levar em conta as permissões e diretórios vazios:

(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

Os argumentos para statfarão com que ele imprima o nome do arquivo, seguido por suas permissões octais. As duas descobertas serão executadas uma após a outra, causando o dobro da quantidade de E / S do disco, a primeira encontrando todos os nomes de arquivos e fazendo a soma de verificação do conteúdo, a segunda encontrando todos os nomes de arquivos e diretórios, imprimindo nome e modo. A lista de "nomes de arquivos e somas de verificação", seguida por "nomes e diretórios, com permissões", terá a soma de verificação para uma soma de verificação menor.

• Use uma ferramenta de detecção de intrusão no sistema de arquivos como um assistente .

• hash um tar ball do diretório:

  tar cvf - /path/to/folder | sha1sum

• Codifique algo você mesmo, como oneliner de vatine :

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

Você pode fazer tar -c /path/to/folder | sha1sum

Se você quiser apenas verificar se algo mudou na pasta, recomendo este:

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

Ele apenas fornecerá um hash da saída do ls, que contém pastas, subpastas, seus arquivos, seu carimbo de data / hora, tamanho e permissões. Praticamente tudo o que você precisa para determinar se algo mudou.

Observe que este comando não gerará hash para cada arquivo, mas é por isso que deve ser mais rápido do que usar find.

Uma abordagem robusta e limpa

• Em primeiro lugar, não monopolize a memória disponível ! Faça hash de um arquivo em partes, em vez de alimentar o arquivo inteiro.
• Abordagens diferentes para necessidades / objetivos diferentes (todos os itens abaixo ou escolha o que for aplicável):
  • Hash apenas o nome da entrada de todas as entradas na árvore de diretórios
  • Hash o conteúdo do arquivo de todas as entradas (deixando o meta como, número do inode, ctime, atime, mtime, tamanho, etc., você entendeu)
  • Para um link simbólico, seu conteúdo é o nome referente. Hash ou opte por pular
  • Siga ou não siga (nome resolvido) o link simbólico enquanto faz o hash do conteúdo da entrada
  • Se for um diretório, seu conteúdo será apenas entradas de diretório. Durante a passagem recursiva, eles terão um hash eventualmente, mas os nomes de entrada de diretório desse nível devem ser hash para marcar este diretório? Útil em casos de uso em que o hash é necessário para identificar uma alteração rapidamente, sem ter que ir fundo para o hash do conteúdo. Um exemplo seria a mudança de nome de um arquivo, mas o resto do conteúdo permanece o mesmo e são todos arquivos bastante grandes
  • Lide bem com arquivos grandes (mais uma vez, lembre-se da RAM)
  • Lidar com árvores de diretório muito profundas (lembre-se dos descritores de arquivo abertos)
  • Lidar com nomes de arquivo não padrão
  • Como proceder com arquivos que são sockets, pipes / FIFOs, dispositivos de bloco, dispositivos char? Deve hash-los também?
  • Não atualize o tempo de acesso de nenhuma entrada durante a travessia, pois isso será um efeito colateral e contraproducente (intuitivo?) Para certos casos de uso.

Isso é o que eu tenho em cima da minha cabeça, qualquer um que passou algum tempo trabalhando nisso praticamente teria pegado outras pegadinhas e casos difíceis.

Aqui está uma ferramenta , muito leve na memória, que atende a maioria dos casos, pode ser um pouco áspera nas bordas, mas tem sido bastante útil.

Um exemplo de uso e saída 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

Um snippet de saída amigável:

...
... //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

Se você quiser apenas hash o conteúdo dos arquivos, ignorando os nomes dos arquivos, então você pode usar

cat $FILES | md5sum

Certifique-se de ter os arquivos na mesma ordem ao calcular o hash:

cat $(echo $FILES | sort) | md5sum

Mas você não pode ter diretórios em sua lista de arquivos.

Outra ferramenta para conseguir isso:

http://md5deep.sourceforge.net/

Como parece: como md5sum, mas também recursivo, além de outros recursos.

Se este for um repositório git e você quiser ignorar todos os arquivos .gitignore, você pode querer usar isto:

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

Isso está funcionando bem para mim.

Existe um script Python para isso:

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

Se você alterar os nomes de um arquivo sem alterar sua ordem alfabética, o script hash não o detectará. Mas, se você alterar a ordem dos arquivos ou o conteúdo de qualquer arquivo, a execução do script fornecerá um hash diferente do anterior.

Tente fazer isso em duas etapas:

1. crie um arquivo com hashes para todos os arquivos em uma pasta
2. hash este arquivo

Igual a:

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

Ou faça tudo de uma vez:

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

Eu canalizaria os resultados para arquivos individuais sort(para evitar uma mera reorganização de arquivos para alterar o hash) para md5sumou sha1sum, o que você escolher.

Eu escrevi um script Groovy para fazer isso:

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

Você pode personalizar o uso para evitar a impressão de cada arquivo, alterar o resumo da mensagem, remover o hash do diretório, etc. Eu testei com os dados de teste do NIST e funciona conforme o esperado. 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

Eu tive que verificar em um diretório inteiro para alterações de arquivo.

Mas excluindo, timestamps, propriedades de diretório.

O objetivo é obter uma soma idêntica em qualquer lugar, se os arquivos forem idênticos.

Incluindo hospedados em outras máquinas, independentemente de qualquer coisa, exceto os arquivos, ou uma mudança neles.

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

Ele gera uma lista de hash por arquivo e, em seguida, concatena esses hashes em um.

Isso é muito mais rápido do que o método tar.

Para maior privacidade em nossos hashes, podemos usar sha512sum na mesma receita.

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

Os hashes também são idênticos em qualquer lugar usando sha512sum, mas não há maneira conhecida de revertê-lo.

Você poderia sha1sumgerar a lista de valores hash e, em seguida, sha1sumessa lista novamente, isso depende do que exatamente você deseja realizar.

Aqui está uma variante simples e curta do Python 3 que funciona bem para arquivos de pequeno porte (por exemplo, uma árvore de origem ou algo assim, onde cada arquivo individualmente pode caber na RAM facilmente), ignorando diretórios vazios, com base nas idéias de outras soluções:

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 assim:

1. Encontre todos os arquivos no diretório recursivamente e classifique-os por nome
2. Calcule o hash (padrão: SHA-1) de cada arquivo (lê o arquivo inteiro na memória)
3. Faça um índice textual com linhas "filename = hash"
4. Codifique esse índice de volta em uma string de bytes UTF-8 e faça o hash

Você pode passar uma função hash diferente como segundo parâmetro se SHA-1 não for sua preferência.