Конечно, должен быть способ сделать это легко!

Я пробовал приложения командной строки Linux, такие как sha1sumи, md5sumно они, похоже, могут вычислять только хэши отдельных файлов и выводить список значений хэшей, по одному для каждого файла.

Мне нужно сгенерировать единый хеш для всего содержимого папки (а не только для имен файлов).

Я бы хотел сделать что-то вроде

sha1sum /folder/of/stuff > singlehashvalue

Изменить: чтобы уточнить, мои файлы находятся на нескольких уровнях в дереве каталогов, они не все находятся в одной корневой папке.

Один из возможных способов:

sha1sum путь / к / папке / * | sha1sum

Если есть целое дерево каталогов, вам, вероятно, лучше использовать find и xargs. Одна из возможных команд была бы

найти путь / к / папке -type f -print0 | sort -z | xargs -0 sha1sum | sha1sum

И, наконец, если вам также нужно учитывать разрешения и пустые каталоги:

(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

Аргументы statзаставят его напечатать имя файла, а затем его восьмеричные разрешения. Эти два поиска будут выполняться один за другим, что приведет к удвоению количества операций ввода-вывода на диске: первое обнаружит все имена файлов и вычислит контрольную сумму содержимого, второе обнаружит все имена файлов и каталогов, имя и режим печати. Список «имен файлов и контрольных сумм», за которым следуют «имена и каталоги с разрешениями», затем будет суммирован для получения меньшей контрольной суммы.

• Используйте средство обнаружения вторжений в файловую систему, например помощник .

• хэш tar-мяч каталога:

  tar cvf - /path/to/folder | sha1sum

• Кодируйте что-нибудь самостоятельно, например, vatine's oneliner :

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

Ты можешь сделать tar -c /path/to/folder | sha1sum

Если вы просто хотите проверить, не изменилось ли что-то в папке, я бы порекомендовал это:

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

Он просто предоставит вам хэш вывода ls, который содержит папки, подпапки, их файлы, их временные метки, размер и разрешения. Практически все, что вам нужно, чтобы определить, изменилось ли что-то.

Обратите внимание, что эта команда не будет генерировать хеш для каждого файла, но именно поэтому она должна быть быстрее, чем при использовании find.

Надежный и чистый подход

• Перво-наперво, не перегружайте доступную память ! Хешируйте файл по частям, а не загружайте файл целиком.
• Различные подходы для разных нужд / целей (все из перечисленных ниже или выберите то, что когда-либо применимо):
  • Хешировать только имя записи всех записей в дереве каталогов
  • Хешируйте содержимое файла всех записей (оставив мета, например, номер inode, ctime, atime, mtime, размер и т. Д., Вы поняли)
  • Для символической ссылки ее содержанием является имя референта. Хешируйте его или выберите пропустить
  • Следовать или не следовать (разрешенное имя) символической ссылке при хешировании содержимого записи
  • Если это каталог, его содержимое - это просто записи каталога. При рекурсивном обходе они в конечном итоге будут хешированы, но следует ли хешировать имена записей каталога этого уровня, чтобы пометить этот каталог? Полезно в случаях использования, когда хеш требуется для быстрого определения изменения без необходимости глубокого обхода для хеширования содержимого. Примером может быть изменение имени файла, но остальное содержимое остается прежним, и все они являются довольно большими файлами.
  • Хорошо обрабатывайте большие файлы (опять же, обратите внимание на оперативную память)
  • Обработка очень глубоких деревьев каталогов (обратите внимание на дескрипторы открытых файлов)
  • Обработка нестандартных имен файлов
  • Как продолжить работу с файлами, которые являются сокетами, каналами / FIFO, блочными устройствами, символьными устройствами? Их тоже нужно хешировать?
  • Не обновляйте время доступа к любой записи во время обхода, потому что это будет побочным эффектом и контрпродуктивным (интуитивно понятным?) Для определенных случаев использования.

Это то, что у меня в голове, любой, кто потратил некоторое время на работу над этим, практически поймал бы другие ловушки и угловые случаи.

Вот инструмент , очень мало использующий память, который подходит для большинства случаев, может быть немного грубоват, но оказался весьма полезным.

Пример использования и вывода 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

Фрагмент удобного для человека вывода:

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

Если вы просто хотите хэшировать содержимое файлов, игнорируя имена файлов, вы можете использовать

cat $FILES | md5sum

При вычислении хэша убедитесь, что файлы расположены в том же порядке:

cat $(echo $FILES | sort) | md5sum

Но у вас не может быть каталогов в вашем списке файлов.

Еще один инструмент для этого:

http://md5deep.sourceforge.net/

Как это звучит: как md5sum, но также рекурсивно, плюс другие функции.

Если это репозиторий git, и вы хотите игнорировать любые файлы в нем .gitignore, вы можете использовать это:

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

У меня это хорошо работает.

Для этого есть скрипт на Python:

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

Если вы измените имена файла без изменения их алфавитного порядка, хеш-скрипт не обнаружит его. Но если вы измените порядок файлов или содержимого любого файла, запуск скрипта даст вам другой хэш, чем раньше.

Мне пришлось проверять весь каталог на предмет изменений в файлах.

Но без учета временных меток и прав собственности на каталоги.

Задача - получить одинаковую везде сумму, если файлы идентичны.

В том числе размещены на других машинах, независимо от чего-либо, кроме файлов или изменений в них.

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

Он генерирует список хэшей по файлам, а затем объединяет эти хэши в один.

Это намного быстрее, чем метод tar.

Для большей конфиденциальности в наших хэшах мы можем использовать sha512sum по тому же рецепту.

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

Хеши также идентичны везде, где используется sha512sum, но нет известного способа отменить его.

Попробуйте сделать это в два этапа:

1. создать файл с хешами для всех файлов в папке
2. хэшировать этот файл

Вот так:

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

Или сделать все сразу:

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

Я бы перенаправил результаты для отдельных файлов sort(чтобы предотвратить простое переупорядочение файлов для изменения хэша) в md5sumили sha1sum, в зависимости от того, что вы выберете.

Для этого я написал сценарий Groovy:

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

Вы можете настроить использование, чтобы избежать печати каждого файла, изменить дайджест сообщения, удалить хеширование каталога и т. Д. Я проверил его на тестовых данных NIST, и он работает, как ожидалось. 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

Вы можете sha1sumсгенерировать список хеш-значений, а затем sha1sumэтот список снова, это зависит от того, что именно вы хотите выполнить.

Вот простой и короткий вариант в Python 3, который отлично работает для файлов небольшого размера (например, исходное дерево или что-то в этом роде, где каждый файл индивидуально может легко поместиться в ОЗУ), игнорируя пустые каталоги, на основе идей из других решений:

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

Это работает так:

1. Рекурсивно найти все файлы в каталоге и отсортировать их по имени
2. Вычислить хэш (по умолчанию: SHA-1) каждого файла (считывает весь файл в память)
3. Сделайте текстовый индекс со строками «filename = hash»
4. Закодируйте этот индекс обратно в байтовую строку UTF-8 и хэш, который

Вы можете передать другую хеш-функцию в качестве второго параметра, если SHA-1 вам не подходит.

Пока что самый быстрый способ сделать это - использовать tar. А с помощью нескольких дополнительных параметров мы также можем избавиться от разницы, вызванной метаданными.

Чтобы использовать tar для хеширования каталога, нужно убедиться, что вы отсортировали путь во время tar, иначе он всегда будет другим.

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

игнорировать время

Если вас не волнует время доступа или время изменения, также используйте что-то вроде, --mtime='UTC 2019-01-01' чтобы убедиться, что все временные метки одинаковы.

игнорировать право собственности

Обычно нам нужно добавить, --group=0 --owner=0 --numeric-ownerчтобы унифицировать метаданные владельца.

игнорировать некоторые файлы

использовать --exclude=PATTERN