Elbette bunu kolayca yapmanın bir yolu olmalı!

Ben Linux komut satırı gibi uygulamalar denedim sha1sumve md5sumancak sadece dosyaları tek tek ve çıkış karma değerlerin listesi, her dosya için bir karma değerlerini hesaplayıp edebilmek görünmektedir.

Bir klasörün tüm içeriği için (sadece dosya adları değil) tek bir karma oluşturmam gerekiyor.

Gibi bir şey yapmak isterim

sha1sum /folder/of/stuff > singlehashvalue

Düzenleme: Açıklığa kavuşturmak gerekirse, dosyalarım bir dizin ağacında birden çok seviyede, hepsi aynı kök klasörde oturmuyor.

Olası bir yol şudur:

sha1sum yol / klasör / * | sha1sum

Tam bir dizin ağacı varsa, muhtemelen find ve xargs'ı kullanmanız daha iyidir. Olası bir komut şöyle olacaktır:

/ klasörün yolunu bul -tip f -print0 | sırala -z | xargs -0 sha1sum | sha1sum

Ve son olarak, izinleri ve boş dizinleri de hesaba katmanız gerekirse:

(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

Argümanlar statdosyanın adını ve ardından sekizlik izinlerini yazdırmasına neden olur. İki buluntu birbiri ardına çalışacak ve iki kat disk IO miktarına neden olacak, ilki tüm dosya adlarını bulup içeriği sağlama, ikincisi tüm dosya ve dizin adlarını, yazdırma adı ve modu. Daha küçük bir sağlama toplamı için "dosya adları ve sağlama toplamları" listesi ve ardından "izinlere sahip adlar ve dizinler" sağlama toplamı alınır.

• Yardımcı gibi bir dosya sistemi saldırı tespit aracı kullanın .

• dizinin katran topunu hash edin:

  tar cvf - /path/to/folder | sha1sum

• Vatine'nin oneliner'ı gibi bir şeyi kendiniz kodlayın :

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

Yapabilirsin tar -c /path/to/folder | sha1sum

Klasördeki bir şeyin değişip değişmediğini kontrol etmek istiyorsanız, bunu tavsiye ederim:

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

Size klasörleri, alt klasörleri, dosyalarını, zaman damgalarını, boyutlarını ve izinlerini içeren ls çıktısının bir karmasını verecektir. Bir şeyin değişip değişmediğini belirlemeniz gereken hemen hemen her şey.

Lütfen bu komutun her dosya için hash oluşturmayacağını unutmayın, ancak bu yüzden find'ı kullanmaktan daha hızlı olması gerektiğini unutmayın.

Sağlam ve temiz bir yaklaşım

• İlk önce, mevcut hafızayı meşgul etmeyin ! Tüm dosyayı beslemek yerine bir dosyayı parçalar halinde karma haline getirin.
• Farklı ihtiyaçlar / amaçlar için farklı yaklaşımlar (aşağıdakilerin tümü veya uygun olanı seçin):
  • Dizin ağacındaki tüm girişlerin yalnızca giriş adını karma hale getirin
  • Tüm girişlerin dosya içeriğini karma haline getirin (meta, inode numarası, ctime, atime, mtime, boyut vb. Gibi bırakarak, fikri anlarsınız)
  • Sembolik bir bağ için içeriği, referans adıdır. Karıştırın veya atlamayı seçin
  • Girişin içeriğine hashing uygularken sembolik bağı takip edin veya takip etmeyin (çözülen ad)
  • Bir dizin ise, içeriği yalnızca dizin girdileridir. Özyinelemeli olarak dolaşırken, sonunda karma işlemi uygulanacaktır, ancak bu seviyenin dizin girişi adlarının bu dizini etiketlemek için karma hale getirilmesi gerekir mi? İçerikleri derinlemesine incelemek zorunda kalmadan bir değişikliği hızlı bir şekilde tanımlamak için karmanın gerekli olduğu kullanım durumlarında faydalıdır. Bir örnek, bir dosyanın adı değişiklikleri olabilir, ancak içeriğin geri kalanı aynı kalır ve hepsi oldukça büyük dosyalardır.
  • Büyük dosyaları iyi yönetin (yine RAM'e dikkat edin)
  • Çok derin dizin ağaçlarını işleyin (açık dosya tanımlayıcılarına dikkat edin)
  • Standart olmayan dosya adlarını işleyin
  • Soket, boru / FIFO, blok aygıt, karakter aygıtı gibi dosyalarla nasıl devam edilir? Onları da hash etmek zorunda mı?
  • Geçiş yaparken herhangi bir girişin erişim zamanını güncellemeyin çünkü bu, belirli kullanım durumları için bir yan etki ve ters etki (sezgisel?) Olacaktır.

Başımın üstünde olan şey bu, bunun üzerinde pratik olarak biraz zaman harcayan herhangi biri, başka sorunlara ve köşe vakalarına yakalanmış olurdu.

İşte , hafızaya çok az önem veren ve çoğu duruma hitap eden bir araç , sınırlarda biraz kaba olabilir, ancak oldukça yardımcı olmuştur.

Örnek bir kullanım ve çıktı 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

İnsan dostu çıktıdan bir pasaj:

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

Dosya adlarını görmezden gelerek sadece dosyaların içeriğine hashing uygulamak istiyorsanız şunu kullanabilirsiniz:

cat $FILES | md5sum

Hash'i hesaplarken dosyaların aynı sırada olduğundan emin olun:

cat $(echo $FILES | sort) | md5sum

Ancak dosya listenizde dizin olamaz.

Bunu başarmak için başka bir araç:

http://md5deep.sourceforge.net/

Sesler olduğu gibi: md5sum gibi ama aynı zamanda özyinelemeli ve diğer özellikler.

Bu bir git deposuysa ve içindeki tüm dosyaları yok saymak istiyorsanız .gitignore, bunu kullanmak isteyebilirsiniz:

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

Bu benim için iyi çalışıyor.

Bunun için bir python betiği var:

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

Alfabetik sırasını değiştirmeden bir dosyanın adlarını değiştirirseniz, karma komut dosyası onu algılamayacaktır. Ancak, dosyaların sırasını veya herhangi bir dosyanın içeriğini değiştirirseniz, komut dosyasını çalıştırmak size öncekinden farklı bir karma verecektir.

Dosya değişiklikleri için tüm dizini kontrol etmem gerekiyordu.

Ancak, zaman damgaları, dizin sahiplikleri hariç tutulduğunda.

Hedef, dosyalar aynıysa, her yerde aynı olan bir toplamı elde etmektir.

Dosyalardan başka hiçbir şeye bakılmaksızın veya bunlarda bir değişiklik olursa, diğer makinelerde barındırılan dahil.

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

Dosyaya göre bir karma listesi oluşturur, ardından bu karmaları tek bir karma halinde birleştirir.

Bu, katran yönteminden çok daha hızlıdır.

Bir İçin güçlü gizlilik bizim sağlamalarının içinde kullanabileceğimiz sha512sum aynı tarifi üzerine.

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

Karmalar da sha512sum kullanan her yerde aynıdır , ancak bunu tersine çevirmenin bilinen bir yolu yoktur.

İki adımda yapmaya çalışın:

1. bir klasördeki tüm dosyalar için karmalar içeren bir dosya oluşturun
2. bu dosyayı hashleyin

Şöyle:

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

Veya hepsini aynı anda yapın:

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

Tek tek dosyalar için sonuçları sort(karmayı değiştirmek için dosyaların yeniden sıralanmasını önlemek için) md5sumveya sha1sumhangisini seçerseniz seçin.

Bunu yapmak için bir Groovy senaryosu yazdım:

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

Her dosyanın yazdırılmasını önlemek, ileti özetini değiştirmek, dizin karmasını çıkarmak vb. İçin kullanımı özelleştirebilirsiniz. NIST test verilerine karşı test ettim ve beklendiği gibi çalışıyor. 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

Sen olabilir sha1sumsonra karma değerlerinin listesini oluşturmak ve sha1sumliste yine, bunu başarmak istediğiniz tam olarak ne bağlıdır.

İşte Python 3'ün küçük boyutlu dosyalar için iyi çalışan basit, kısa bir çeşidi (örneğin, her dosyanın ayrı ayrı RAM'e kolayca sığabileceği bir kaynak ağacı veya başka bir şey), diğer çözümlerin fikirlerine dayanarak boş dizinleri yok sayarak:

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

Şu şekilde çalışır:

1. Dizindeki tüm dosyaları yinelemeli olarak bulun ve ada göre sıralayın
2. Her dosyanın karmasını (varsayılan: SHA-1) hesaplayın (tüm dosyayı belleğe okur)
3. "Filename = hash" satırlarıyla metinsel bir dizin oluşturun
4. Bu dizini UTF-8 baytlık bir dizeye kodlayın ve

SHA-1 sizin fincan çayınız değilse , farklı bir hash fonksiyonunu ikinci parametre olarak geçirebilirsiniz .

Şimdiye kadar bunu yapmanın en hızlı yolu hala katran kullanmaktır. Ve birkaç ek parametre ile, meta verilerin neden olduğu farktan da kurtulabiliriz.

Dizin için tar kullanmak için , yolu tar sırasında sıraladığınızdan emin olmanız gerekir , aksi takdirde her zaman farklıdır.

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

zamanı görmezden gel

Erişim zamanını veya değiştirme zamanını --mtime='UTC 2019-01-01' önemsemiyorsanız, tüm zaman damgalarının aynı olduğundan emin olmak gibi bir şey de kullanın .

sahipliği görmezden gel

Genellikle --group=0 --owner=0 --numeric-ownersahip meta verilerini birleştirmek için eklememiz gerekir .

bazı dosyaları yok say

kullanım --exclude=PATTERN