लिनक्स: किसी दिए गए फ़ोल्डर और सामग्री के लिए एक एकल हैश की गणना करें?

Question

निश्चित रूप से इसे आसानी से करने का एक तरीका होना चाहिए!

मैंने लिनक्स कमांड-लाइन ऐप्स जैसे कि कोशिश की है sha1sumऔर md5sumवे केवल व्यक्तिगत फ़ाइलों की हैश की गणना करने और प्रत्येक फ़ाइल के लिए हैश मानों की एक सूची आउटपुट करने में सक्षम हैं।

मुझे एक फ़ोल्डर की संपूर्ण सामग्री (न केवल फ़ाइल नाम) के लिए एक एकल हैश उत्पन्न करने की आवश्यकता है।

मैं कुछ ऐसा करना चाहूंगा

sha1sum /folder/of/stuff > singlehashvalue

संपादित करें: स्पष्ट करने के लिए, मेरी फाइलें एक निर्देशिका ट्री में कई स्तरों पर हैं, वे सभी एक ही रूट फ़ोल्डर में नहीं बैठे हैं।

Comments

'संपूर्ण सामग्री' से क्या आप मूल हैश में आने के दौरान डायरेक्टरी की सभी फाइलों के तार्किक डेटा या मेटा के साथ इसके डेटा का मतलब रखते हैं? चूंकि आपके उपयोग के मामले का चयन मानदंड काफी व्यापक है, इसलिए मैंने अपने उत्तर में कुछ व्यावहारिक लोगों को संबोधित करने की कोशिश की है।

— छह-के

Answer 1

एक संभावित तरीका होगा:

sha1sum पथ / to / folder / * | sha1sum

यदि पूरी निर्देशिका का पेड़ है, तो आप शायद ढूंढने और xargs का उपयोग करने से बेहतर हैं। एक संभावित आदेश होगा

पाथ / / to / folder -type f -print0 | सॉर्ट -ज | 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फ़ाइल के नाम को मुद्रित करने का कारण होगा, इसके बाद इसकी अष्टाधारी अनुमतियाँ। दो खोज एक के बाद एक चलेंगे, जिससे डिस्क IO की मात्रा दोगुनी हो जाएगी, पहला सभी फ़ाइल नामों को ढूंढना और सामग्री की जांच करना, दूसरा सभी फ़ाइल और निर्देशिका नामों, मुद्रण नाम और मोड को खोजना होगा। "फ़ाइल नाम और चेकसम" की सूची, उसके बाद "नाम और निर्देशिका, अनुमतियों के साथ" फिर चेकसम की जाँच की जाएगी, एक छोटे संग्रह के लिए।

Comments

और LC_ALL = POSIX सेट करना न भूलें, इसलिए विभिन्न उपकरण स्थानीय स्वतंत्र आउटपुट बनाते हैं।

— डेविड श्मिट

मुझे बिल्ली मिली | sha1sum sha1sum की तुलना में काफी तेज होना चाहिए | sha1sum। YMMV, अपने सिस्टम पर इनमें से प्रत्येक का प्रयास करें: समय पाएं / पाएं / to-folder -type f -print0 | सॉर्ट -ज | xargs -0 sha1sum | sha1sum; समय पा रास्ता / / to / folder -type f -print0 | सॉर्ट -ज | xargs -0 बिल्ली | sha1sum

— ब्रूनो ब्रोंस्की

@RichardBronosky - मान लें कि हमारे पास दो फाइलें हैं, A और B. A में "फू" है और B में "बार यहां था" है। आपकी विधि के साथ, हम उसे दो फ़ाइलों C और D से अलग नहीं कर पाएंगे, जहाँ C में "फ़ॉबोर" और D सम्‍मिलित है "यहाँ था"। व्यक्तिगत रूप से प्रत्येक फ़ाइल को हैशिंग द्वारा और फिर सभी "फ़ाइल नाम हैश" जोड़े, हम अंतर देख सकते हैं।

— वेटिन

इस कार्य को निर्देशिका पथ के बावजूद (अर्थात जब आप दो अलग-अलग फ़ोल्डरों के हैश की तुलना करना चाहते हैं), आपको एक सापेक्ष पथ का उपयोग करने और उपयुक्त निर्देशिका में परिवर्तन करने की आवश्यकता है, क्योंकि पथ अंतिम हैश में शामिल हैं:find ./folder -type f -print0 | sort -z | xargs -0 sha1sum | sha1sum

— डकैती

@robbles यह सही है और मैंने बिट /पर प्रारंभिक क्यों नहीं लगाया path/to/folder।

— वेटिन

Answer 2

• जैसे एक फाइल सिस्टम घुसपैठ का पता लगाने उपकरण का उपयोग सहयोगी ।

• हैश निर्देशिका की एक टार बॉल:

  tar cvf - /path/to/folder | sha1sum

• कुछ अपने आप को कोड करें, जैसे कि वैटीन के ऑनलाइनर :

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

Comments

टार समाधान के लिए +1। यह सबसे तेज है, लेकिन वी। ड्रॉपबोसिटी केवल इसे धीमा कर देती है।

— ब्रूनो ब्रोंस्की

ध्यान दें कि जब आप उनकी तुलना करते हैं तो टार सॉल्यूशन फाइलों को एक ही क्रम में रखता है। क्या वे फाइल सिस्टम पर निर्भर होंगे कि तुलना करते समय फाइलें कहां रहती हैं।

— ओपन स्कूल

गिट हैश इस उद्देश्य के लिए उपयुक्त नहीं है क्योंकि फ़ाइल सामग्री केवल इसके इनपुट का एक हिस्सा है। यहां तक ​​कि एक शाखा की प्रारंभिक प्रतिबद्धता के लिए, हैश प्रतिबद्ध संदेश और प्रतिबद्ध मेटाडेटा से प्रभावित होता है, जैसे कि प्रतिबद्ध समय। यदि आप एक ही निर्देशिका संरचना को कई बार करते हैं, तो आपको हर बार अलग-अलग हैश मिलेगा, इस प्रकार परिणामी हैश यह निर्धारित करने के लिए उपयुक्त नहीं है कि क्या दो निर्देशिका केवल हैश ओवर भेजकर एक दूसरे की सटीक प्रतियां हैं।

— ज़ोल्टन

@Zoltan git हैश पूरी तरह से ठीक है, यदि आप एक पेड़ हैश का उपयोग करते हैं और एक प्रतिबद्ध हैश नहीं।

— Hobbs

@hobbs उत्तर मूल रूप से "प्रतिबद्ध हैश" कहा गया है, जो निश्चित रूप से इस उद्देश्य के लिए फिट नहीं है। पेड़ हैश एक बेहतर उम्मीदवार की तरह लगता है, लेकिन अभी भी छिपे हुए जाल हो सकते हैं। एक बात जो मेरे दिमाग में आती है, वह यह है कि कुछ फाइलों पर निष्पादन योग्य बिट सेट होने से ट्री हैश बदल जाता है। git config --local core.fileMode falseइससे बचने के लिए आपको प्रतिबद्ध होने से पहले जारी करना होगा। मुझे नहीं पता कि इस तरह के कोई और दावे हैं या नहीं।

— ज़ोल्टन

Answer 3

तुम कर सकते हो tar -c /path/to/folder | sha1sum

Comments

यदि आप एक अलग मशीन पर उस चेकसम को दोहराना चाहते हैं, तो टार एक अच्छा विकल्प नहीं हो सकता है, क्योंकि प्रारूप अस्पष्टता के लिए जगह है और कई संस्करणों में मौजूद है, इसलिए किसी अन्य मशीन पर टार एक ही फाइलों से अलग आउटपुट का उत्पादन कर सकता है।

— धीमी गति से

slowdog के वैध चिंताओं, के होते हुए भी आप फ़ाइल की सामग्री, अनुमतियाँ, आदि के बारे में परवाह नहीं बल्कि संशोधन समय, आप जोड़ सकते हैं, तो --mtimeइसलिए की तरह विकल्प: tar -c /path/to/folder --mtime="1970-01-01" | sha1sum।

— बाइनरी फ़िले

@ S। अगर निर्देशिका का आकार बड़ा है, तो मेरा मतलब है कि यदि निर्देशिका का आकार इतना बड़ा है, तो इसे ज़िप करना और उस पर md5 प्राप्त करने में अधिक समय लगेगा

— कसुन सियामबलपिटिया

Answer 4

यदि आप केवल यह देखना चाहते हैं कि क्या फ़ोल्डर में कुछ बदला गया है, तो मैं इसे सुझाऊंगा:

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

यह आपको केवल ls आउटपुट का एक हैश देगा, जिसमें फ़ोल्डर्स, सब-फ़ोल्डर्स, उनकी फाइलें, उनका टाइमस्टैम्प, आकार और अनुमतियां शामिल हैं। बहुत कुछ सब कुछ है कि आप अगर कुछ बदल गया है निर्धारित करने की आवश्यकता होगी।

कृपया ध्यान दें कि यह कमांड प्रत्येक फ़ाइल के लिए हैश उत्पन्न नहीं करेगा, लेकिन यही कारण है कि इसे खोजने का उपयोग करने से तेज होना चाहिए।

Comments

मैं अनिश्चित हूं कि इस समाधान की सादगी को देखते हुए यह अधिक upvotes नहीं है। क्या कोई समझा सकता है कि यह अच्छा काम क्यों नहीं करेगा?

— डेव सी

मुझे लगता है कि यह आदर्श नहीं है क्योंकि उत्पन्न हैश फ़ाइल स्वामी, दिनांक-प्रारूप सेटअप, आदि पर आधारित होगा

— Ryota

Ls कमांड को आप जो चाहें आउटपुट के लिए कस्टमाइज़ किया जा सकता है। आप -lG के साथ -l को ग्रुप और ओनर को छोड़ने के लिए बदल सकते हैं। और आप - समय-शैली विकल्प के साथ दिनांक स्वरूप बदल सकते हैं। मूल रूप से ls मैन पेज देखें और देखें कि आपकी आवश्यकताओं के अनुरूप क्या है।

— शुमप्प्प

@DaveC क्योंकि यह बहुत बेकार है। यदि आप फ़ाइल नाम की तुलना करना चाहते हैं, तो सीधे उनकी तुलना करें। वे उतने बड़े नहीं हैं।

— नवीन १

@Navin इस सवाल से यह स्पष्ट नहीं है कि क्या सामग्री को हैश करना या पेड़ में बदलाव का पता लगाना आवश्यक है। प्रत्येक मामले के अपने उपयोग हैं। उदाहरण के लिए, कर्नेल ट्री में 45K फाइलन का भंडारण करना, एक हैश की तुलना में कम व्यावहारिक है। ls -lAgGR --block-size = 1 --time-style = +% s | sha1sum मेरे लिए बहुत अच्छा काम करता है

— yashma

Answer 5

एक मजबूत और स्वच्छ दृष्टिकोण

• पहली चीजें पहले, उपलब्ध स्मृति को हॉग मत करो! पूरी फाइल को फीड करने की बजाय किसी फाइल को चंक्स में रखें।
• विभिन्न आवश्यकताओं / उद्देश्य के लिए अलग-अलग दृष्टिकोण (सभी नीचे दिए गए या जो कभी लागू होते हैं, उन्हें चुनें):
  • डायरेक्ट्री ट्री में सभी प्रविष्टियों का केवल नाम दर्ज करें
  • सभी प्रविष्टियों की फ़ाइल सामग्री को हैश करें (जैसे मेटा, इनोड संख्या, समय, Atime, माइम, आकार, आदि को छोड़कर, आपको यह विचार मिलता है)
  • एक प्रतीकात्मक लिंक के लिए, इसकी सामग्री संदर्भ नाम है। इसे हैश करें या स्किप करना चुनें
  • प्रविष्टि की सामग्री को हैशिंग करते समय सिम्लिंक का पालन करें या नहीं (हल किए गए नाम) का पालन करें
  • यदि यह एक निर्देशिका है, तो इसकी सामग्री केवल निर्देशिका प्रविष्टियाँ हैं। पुनरावर्ती रूप से ट्रेस करते समय उन्हें अंततः हैश किया जाएगा, लेकिन क्या इस स्तर की डायरेक्टरी प्रविष्टि के नाम इस निर्देशिका को टैग करने के लिए हैशेड होना चाहिए? उपयोग के मामलों में मदद करने के लिए जहां हैश को सामग्री को हैश करने के लिए गहराई से आघात किए बिना एक बदलाव को जल्दी से पहचानने की आवश्यकता होती है। एक उदाहरण एक फ़ाइल का नाम परिवर्तन होगा, लेकिन बाकी सामग्री समान हैं और वे सभी काफी बड़ी फाइलें हैं
  • बड़ी फ़ाइलों को अच्छी तरह से संभाल लें (फिर से, मन को राम करें)
  • बहुत गहरी निर्देशिका पेड़ों को संभालें (ओपन फाइल डिस्क्रिप्टर पर ध्यान दें)
  • गैर मानक फ़ाइल नाम संभालें
  • सॉकेट, पाइप / फीफो, ब्लॉक डिवाइसेस, चार डिवाइसेस वाली फ़ाइलों के साथ कैसे आगे बढ़ें? उन्हें भी हैश करना चाहिए?
  • ट्रैवर्स करते समय किसी भी प्रविष्टि के एक्सेस समय को अपडेट न करें क्योंकि यह कुछ उपयोग मामलों के लिए एक साइड इफेक्ट और काउंटर-उत्पादक (सहज) होगा।

यह वही है जो मेरे सिर के ऊपर है, किसी भी व्यक्ति ने जो कुछ समय इस व्यावहारिक रूप से काम करने में बिताया है उसने अन्य गोचरों और कोने के मामलों को पकड़ा होगा।

यहां एक उपकरण है , जो स्मृति पर बहुत हल्का है, जो ज्यादातर मामलों को संबोधित करता है, किनारों के आसपास थोड़ा मोटा हो सकता है लेकिन काफी मददगार रहा है।

एक उदाहरण का उपयोग और आउटपुट 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

Comments

क्या आप एक फ़ोल्डर का एक मजबूत और स्वच्छ sha256 प्राप्त करने के लिए एक संक्षिप्त उदाहरण दे सकते हैं, शायद तीन उपनिर्देशिकाओं के साथ विंडोज फ़ोल्डर के लिए और प्रत्येक में कुछ फाइलें?

— फेरी

Answer 6

यदि आप केवल फ़ाइल की सामग्री को हैश करना चाहते हैं, तो फ़ाइल नाम को अनदेखा करना तो आप उपयोग कर सकते हैं

cat $FILES | md5sum

सुनिश्चित करें कि आपके पास हैश की गणना करते समय उसी क्रम में फाइलें हों:

cat $(echo $FILES | sort) | md5sum

लेकिन आपकी फ़ाइलों की सूची में निर्देशिका नहीं हो सकती है।

Comments

एक फ़ाइल के अंत में उस फ़ाइल की शुरुआत में ले जाना जो इसे वर्णानुक्रम में अनुसरण करती है, वह हैश को प्रभावित नहीं करेगी, लेकिन होनी चाहिए। फ़ाइल-सीमांकक या फ़ाइल की लंबाई को हैश में शामिल करना होगा।

— जेसन स्टैंगरोम

Answer 7

इसे प्राप्त करने के लिए एक और उपकरण:

http://md5deep.sourceforge.net/

जैसा कि लगता है: md5sum की तरह, लेकिन पुनरावर्ती, प्लस अन्य विशेषताएं भी।

Comments

हालांकि यह लिंक प्रश्न का उत्तर दे सकता है, लेकिन उत्तर के आवश्यक भागों को शामिल करना और संदर्भ के लिए लिंक प्रदान करना बेहतर है। लिंक-केवल उत्तर अमान्य हो सकते हैं यदि लिंक किए गए पृष्ठ बदल जाते हैं।

— मैमून बेंगज़ल

Answer 8

यदि यह एक git रेपो है और आप किसी भी फाइल को अनदेखा करना चाहते हैं .gitignore, तो आप इसका उपयोग करना चाहते हैं:

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

यह मेरे लिए अच्छा काम कर रहा है।

Comments

आपका बहुत बहुत धन्यवाद! :)

— 11

कई अनुप्रयोगों के लिए यह दृष्टिकोण बेहतर है। बस स्रोत कोड फ़ाइलों को हाशिए करने से बहुत कम समय में पर्याप्त रूप से अद्वितीय हैश प्राप्त होता है।

— जॉन मैकगी ने

Answer 9

उसके लिए एक अजगर लिपि है:

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

यदि आप उनके वर्णमाला क्रम को बदले बिना किसी फ़ाइल का नाम बदलते हैं, तो हैश स्क्रिप्ट इसका पता नहीं लगाएगी। लेकिन, यदि आप फ़ाइलों के क्रम या किसी फ़ाइल की सामग्री को बदलते हैं, तो स्क्रिप्ट चलाना आपको पहले से अलग हैश प्रदान करेगा।

Answer 10

मुझे फ़ाइल परिवर्तनों के लिए पूरी निर्देशिका में जाँच करनी थी।

लेकिन छोड़कर, टाइमस्टैम्प, निर्देशिका स्वामित्व।

लक्ष्य कहीं भी समरूप राशि प्राप्त करना है, यदि फाइलें समान हैं।

अन्य मशीनों में होस्ट किए गए, कुछ भी, लेकिन फाइलों, या उन में बदलाव सहित।

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

यह फ़ाइल द्वारा हैश की एक सूची उत्पन्न करता है, फिर उन हैश को एक में समाहित करता है।

यह टार विधि की तुलना में तेज़ है।

हमारे हैश में एक मजबूत गोपनीयता के लिए , हम एक ही नुस्खा पर sha512sum का उपयोग कर सकते हैं ।

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

हैश भी sha512sum का उपयोग करने के लिए कहीं भी समान हैं लेकिन इसे रिवर्स करने का कोई ज्ञात तरीका नहीं है।

Comments

यह हैशिंग निर्देशिका के लिए स्वीकृत उत्तर की तुलना में बहुत सरल लगता है। मुझे स्वीकृत उत्तर विश्वसनीय नहीं लग रहा था। एक मुद्दा ... क्या एक मौका है कि एक अलग क्रम में हैश निकल सकता है? sha256sum /tmp/thd-agent/* | sortक्या मैं एक विश्वसनीय आदेश के लिए कोशिश कर रहा हूँ, तो बस हैशिंग कि।

— सोचिए

नमस्ते, ऐसा लगता है कि डिफ़ॉल्ट रूप से हैश वर्णमाला क्रम में आता है। विश्वसनीय आदेश देने से आपका क्या तात्पर्य है? आपको वह सब अपने आप से व्यवस्थित करना होगा। उदाहरण के लिए साहचर्य सरणियों का उपयोग, प्रवेश + हैश। फिर आप इस सरणी को प्रविष्टि द्वारा सॉर्ट करते हैं, यह क्रमबद्ध क्रम में गणना की गई हैश की सूची देता है। मेरा मानना ​​है कि आप अन्यथा किसी ऑब्जेक्ट का उपयोग कर सकते हैं, और पूरे ऑब्जेक्ट को सीधे हैश कर सकते हैं।

— एनवीआरएम

अगर मुझे लगता है कि आप कह रहे हैं कि यह वर्णमाला के क्रम में फाइल हैश कर रहा है। जो सही लगता है। ऊपर दिए गए स्वीकृत उत्तर में कुछ मुझे कभी-कभी अलग-अलग आदेश दे रहा था, इसलिए मैं बस यह सुनिश्चित करने की कोशिश कर रहा हूं कि फिर से ऐसा न हो। मैं अंत में छाँटने के साथ रहना चाहता हूँ। काम करने लगता है। केवल इस विधि बनाम स्वीकृत उत्तर के साथ मैं देख रहा हूं कि यह नेस्टेड फ़ोल्डर्स के साथ सौदा नहीं है। मेरे मामले में मेरे पास कोई फ़ोल्डर नहीं है इसलिए यह बहुत अच्छा काम करता है।

— सोचिए

किस बारे में ls -r | sha256sum?

— एनवीआरएम

@NVRM ने इसे आज़माया और यह केवल फ़ाइल नाम परिवर्तनों के लिए जाँची, न कि फ़ाइल सामग्री के लिए

— Gi0rgi0s

Answer 11

इसे दो चरणों में बनाने का प्रयास करें:

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

Comments

for F in 'find ...' ...काम नहीं करता है जब आपके पास नामों में स्थान होता है (जो आप हमेशा आजकल करते हैं)।

— mivk

Answer 12

मैं व्यक्तिगत फ़ाइलों के लिए परिणामों को पाइप के माध्यम से sort(हैश को बदलने के लिए फ़ाइलों के एक मात्र पुनरावृत्ति को रोकने के लिए) में , md5sumया sha1sumजो भी आप चुनते हैं।

Answer 13

मैंने ऐसा करने के लिए एक ग्रूवी स्क्रिप्ट लिखी है:

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

Answer 14

आप sha1sumहैश मानों की सूची और फिर sha1sumउस सूची को फिर से जेनरेट कर सकते हैं , यह इस बात पर निर्भर करता है कि आप क्या हासिल करना चाहते हैं।

Answer 15

यहाँ Python 3 में एक सरल, छोटा संस्करण है, जो छोटे आकार की फ़ाइलों के लिए ठीक काम करता है (उदाहरण के लिए एक स्रोत का पेड़ या ऐसी चीज़, जहाँ हर फ़ाइल व्यक्तिगत रूप से RAM में आसानी से फिट हो सकती है), खाली निर्देशिका को अनदेखा करते हुए, अन्य समाधानों के विचारों के आधार पर:

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. "फ़ाइल नाम = हैश" लाइनों के साथ एक पाठ अनुक्रमणिका बनाएं
4. उस इंडेक्स को वापस UTF-8 बाइट स्ट्रिंग में एन्कोड करें और हैश करें

यदि आप SHA-1 आपके कप चाय नहीं हैं तो आप दूसरे हैश फ़ंक्शन में दूसरे पैरामीटर के रूप में पास कर सकते हैं ।