एक आदेश के साथ डंप md5 और sha1 चेकसम!

Question

मैं एक कमांड द्वारा md5 , sha1 हैश मान की गणना के लिए कमांड या उपयोगिताओं की तलाश कर रहा हूं ।
अभी ubuntu है sha1sumऔर md5sumगणना करने के लिए आदेश hashमूल्य।

Comments

तुम यह क्यों चाहते हैं? आमतौर पर आप उन्हें बनाने के बाद हैश को सत्यापित करने में सक्षम होना चाहते हैं। उदाहरण के लिए, हैश उत्पन्न करने के लिए md5sum hosts:। फिर, इस परिणाम को सत्यापित करने के: echo "b9adfb2e2022a3a84ba06b55eeb2dc64 hosts" | md5sum --check: (देना चाहिए hosts: OK)

— Lekensteyn

मान लें कि 500 ​​जीबी हार्ड ड्राइव की 'हैश वैल्यू' की गणना करना चाहते हैं, तो दोनों sha1 और md5। अगर मैं एक-एक करके गणना करता हूं (sha1sum और md5sum का उपयोग करके) तो दोहरा समय लगेगा। लेकिन अगर सिंगल यूटिलिटीज के साथ ही विंडोज सॉफ्टवेयर के साथ काम किया जा सकता है तो यह मेरा वांछित जवाब होगा।

— एमएस परमार

Answer 1

आप इसे कुछ उचित बैश निंजा-फू के साथ प्राप्त कर सकते हैं। :)

आप एक समय में एक की गणना करने की प्रक्रिया जानते हैं:

$ echo abc | md5sum
0bee89b07a248e27c83fc3d5951213c1  -
$ echo abc | sha1sum
03cfd743661f07975fa2f1220c5194cbaff48451  -

संपादित करें: जैसा कि @gertvdijk ने सुझाव दिया है, और जानकारी पृष्ठों को थोड़ा और पढ़ना है, यह सीधे आधुनिक शेल द्वारा समर्थित टी और प्रोसेस सबस्टीट्यूशन के साथ किया जा सकता है, बिना रीडायरेक्ट के। इस तरह से आप अपने डेटा को दो प्रक्रियाओं और एक फ़ाइल का उपयोग कर पास कर सकते हैं:

$ echo abc | tee >(md5sum) >(sha1sum) > output.txt

यदि आपको और अधिक की आवश्यकता है, तो चेन करना भी संभव है, लेकिन आपको सभी उपप्रकारों से STDOUT का ध्यान रखना होगा। यह आपको अपेक्षित परिणाम नहीं देगा, लेकिन पहले दो चेकसमों को आउटपुट में डेटा के साथ मिलाता है।

$ echo abc | tee >(md5sum) >(sha1sum) | tee >(sha256sum) >(sha512sum) > output.txt

यदि आप प्रतिस्थापित प्रक्रियाओं के अंदर चेकसम को एक फ़ाइल में पुनर्निर्देशित करते हैं, तो आप इन्हें अपनी पसंद के अनुसार श्रृंखलाबद्ध कर सकते हैं:

$ echo abc | tee >(md5sum > /tmp/md5.txt) >(sha1sum > /tmp/sha1.txt) | tee >(sha256sum > /tmp/sha256.txt) >(sha512sum > /tmp/sha512.txt) > output.txt

यहां प्रक्रिया प्रतिस्थापन के बिना मेरा प्रारंभिक सुझाव है, लेकिन जो डेटा और आउटपुट को मिलाए बिना चैनिंग / पुनरावर्ती उपयोग की अनुमति देता है:

$ echo abc | tee -a /proc/self/fd/2 2> >(sha1sum) > >(md5sum)
0bee89b07a248e27c83fc3d5951213c1  -
03cfd743661f07975fa2f1220c5194cbaff48451  -

यहां ट्रिक का उपयोग करना है tee, जो डेटा को STDOUT और एक फाइल को डुप्लिकेट करता है। हम डेटा को फ़ाइल / proc / self / fd / 2 में लिखने के लिए यह कहकर चालाक हो रहे हैं, जो हमेशा वर्तमान प्रक्रिया 'STDERR फ़ाइल डिस्क्रिप्टर' के रूप में होता है। और > >(program)सिंटैक्स के साथ हम एक फ़ाइल के बजाय प्रत्येक फ़ाइल डिस्क्रिप्टर को प्रोग्राम के STDIN पर पुनर्निर्देशित कर सकते हैं। बस की तरह |, लेकिन अधिक नियंत्रण के साथ। कार्यक्रम में > >(md5sum)STDOUT को पुनर्निर्देशित करता md5sumहै, जबकि 2> >(sha1sum)STDERR को sha1sumकार्यक्रम में पुनर्निर्देशित करता है।

ध्यान दें कि आदेश के बारे में 2>और >लगता है, मुझे 2>पहले कमांड लाइन पर रखना होगा । इनका मूल्यांकन दाईं से बाईं ओर किया जाता है, लेकिन मुझे यकीन नहीं है कि इससे फर्क पड़ता है।

फ़ाइल या हार्ड ड्राइव पर ऐसा करने के लिए, आपको "इको एबीसी" को बिल्ली या डीडी से बदलना चाहिए, जैसे:

dd if=/dev/sda bs=8k | tee -a /proc/self/fd/2 2> >(sha1sum) > >(md5sum)

इसके बारे में निफ्टी बात यह है कि आप वास्तव में केवल दो ही नहीं, एक ही समय में कई पुनरावृत्ति कर सकते हैं। वाक्य रचना बालों वाली हो जाती है, लेकिन यह काम करती है:

echo abc | tee -a /proc/self/fd/2 2> >(tee -a /proc/self/fd/2 2> >(sha256sum) > >(sha384sum) ) > >(sha512sum)

यदि आप परिणाम को कैप्चर करना चाहते हैं और इसे स्क्रिप्ट में उपयोग करना चाहते हैं, तो यह भी काम करता है:

A=$(echo abc | tee -a /proc/self/fd/2 2> >(sha1sum) > >(md5sum))

अब $Aएक स्ट्रिंग है जिसमें सभी आउटपुट हैं, जिसमें newlines भी शामिल है। आप मानों को बाद में भी पार्स कर सकते हैं:

echo "checksum=[$(echo "$A" | head -1 | cut -d " " -f 1)]"

मुझे यकीन नहीं है कि आपके पास आउटपुट के आदेश के बारे में कोई गारंटी है।

Comments

+1। teeऔर शेल में आउटपुट पुनर्निर्देशन का चतुर उपयोग जाने का रास्ता है। यह बहुत सारे संसाधनों को बचाता है, खासकर जब बड़ी फ़ाइलों को पढ़ते हुए।

— gertvdijk

वैसे, मुझे लगता है कि आपको स्ट्रीम के आउटपुट को डुप्लिकेट करने के लिए stderr पर पुनर्निर्देशित करने की आवश्यकता नहीं है। एक उप-प्रकार का उपयोग चालबाज़ी को भी बनाए रखेगा। मेरा उदाहरण यहाँ एक ब्लॉग पोस्ट में देखें ।

— gertvdijk 11

@gertvdijk अधिकार, प्रक्रिया प्रतिस्थापन क्लीनर है, और श्रृंखला के लिए आसान है (आपको पुनरावृत्ति करने की आवश्यकता नहीं है)। मैं अपनी प्रतिक्रिया अपडेट करूंगा।

— ketil

अच्छा लगा। अगर मैं कर सकता तो मैं आपको एक और अपवोट देता। :-)

— gertvdijk 12

हालांकि ये अच्छी छोटी फ़ाइलों के लिए अच्छी तरह से काम करते हैं, आप बड़ी फ़ाइलों के लिए प्रयासों और प्रसंस्करण समय को दोगुना कर रहे हैं, जो मैं बचने के लिए देख रहा हूं ...

— EkriirkE

Answer 2

खिचड़ी भाषा आपको कमांड लाइन के साथ मदद करती है, लेकिन मुझे एक GUI टूल का नाम दिया गया है जिसे क्विकश कहते हैं।

आप उस टूल को क्विकश से डाउनलोड कर सकते हैं

विवरण:

एक लिनक्स और विंडोज जीयूआई फाइलों के तेजी से चयन और बाद के हैशिंग को (एक फ़ोल्डर संरचना में व्यक्तिगत रूप से या पुनरावर्ती रूप से) पाठ और (लिनक्स पर) डिस्क को सक्षम करने के लिए। लिनक्स के लिए डिज़ाइन किया गया है, लेकिन विंडोज के लिए भी उपलब्ध है। MD5, SHA1, SHA256, SHA512 उपलब्ध है। आउटपुट को क्लिपबोर्ड पर कॉपी किया गया या CSV \ HTML फ़ाइल के रूप में सहेजा गया।

Answer 3

Here i have find one python script from source which calculate hash values. and also i find some statistics about hash value calculation.

 - `md5sum` takes 00:3:00 min to calculate 4GB USB.
 - `sha2sum` takes 00:3:01 min to calculate 4GB USB.
 - While phython script takes 3:16 min to calculate both MD5 and SHA1.

// स्क्रिप्ट की शुरुआत यहीं से होती है

def get_custom_checksum(input_file_name):
    from datetime import datetime
    starttime = datetime.now()
    # START: Actual checksum calculation
    from hashlib import md5, sha1, sha224, sha384, sha256, sha512
    #chunk_size = 1 # 1 byte -- NOT RECOMENDED -- USE AT LEAST 1KB. When 1KB takes 1 min to run, 1B takes 19 minutes to run
    #chunk_size = 1024 # 1 KB
    chunk_size = 1048576 # 1024 B * 1024 B = 1048576 B = 1 MB
    file_md5_checksum = md5()
    file_sha1_checksum = sha1()

    try:
        with open(input_file_name, "rb") as f:
            byte = f.read(chunk_size)
            previous_byte = byte
            byte_size = len(byte)
            file_read_iterations = 1
            while byte:
                file_md5_checksum.update(byte)
                file_sha1_checksum.update(byte)               
                previous_byte = byte
                byte = f.read(chunk_size)
                byte_size += len(byte)
                file_read_iterations += 1
    except IOError:
        print ('File could not be opened: %s' % (input_file_name))
        #exit()
        return
    except:
        raise
    # END: Actual checksum calculation
    # For storage purposes, 1024 bytes = 1 kilobyte
    # For data transfer purposes, 1000 bits = 1 kilobit
    kilo_byte_size = byte_size/1024
    mega_byte_size = kilo_byte_size/1024
    giga_byte_size = mega_byte_size/1024
    bit_size = byte_size*8
    kilo_bit_size = bit_size/1000
    mega_bit_size = kilo_bit_size/1000
    giga_bit_size = mega_bit_size/1000
    last_chunk_size = len(previous_byte)
    stoptime = datetime.now()
    processtime = stoptime-starttime
    custom_checksum_profile = {
        'starttime': starttime,
        'byte_size': byte_size,
        'kilo_byte_size': kilo_byte_size,
        'mega_byte_size': mega_byte_size,
        'giga_byte_size': giga_byte_size,
        'bit_size': bit_size,
        'kilo_bit_size': kilo_bit_size,
        'mega_bit_size': mega_bit_size,
        'giga_bit_size': giga_bit_size,
        'file_read_iterations': file_read_iterations,
        'last_chunk_size': last_chunk_size,
        'md5_checksum': file_md5_checksum.hexdigest(),
        'sha1_checksum': file_sha1_checksum.hexdigest(),        
        'stoptime': stoptime,
        'processtime': processtime,
        }
    return custom_checksum_profile



def print_custom_checksum(input_file_name):
    custom_checksum_profile = get_custom_checksum(input_file_name)
    try:
        print 'Start Time ::', custom_checksum_profile['starttime']

custom_checksum_profile ['file_read_iterations']] # प्रिंट ('लास्ट चंक (बाइट्स):', custom_checksum_profile ['last_chunk_size']]) print 'MD5 ::', custom_checksum_profile ['md5_checksum'] 'प्रिंट'] 'प्रिंट') '] प्रिंट' स्टॉप टाइम :: ', custom_checksum_profile [' stoptime '] प्रिंट' प्रोसेसिंग टाइम :: ',' custom_checksum_profile ['processtime'] टाइप के अलावा कुछ भी नहीं: # NoTType 'ऑब्जेक्ट सबस्क्रिप्टेबल नहीं है --- मूल रूप से ऐसा तब होना चाहिए जब यह हो। इनपुट फ़ाइल #raise पास # सीएसवी आउटपुट नहीं खोला जा सका

import argparse
script_version='0.0.2'
parser = argparse.ArgumentParser(description='Determine and print various checksums of an input file and its size. Supported checksums are MD5, SHA1, SHA224, SHA256, SHA384, and SHA512.', version=script_version)
parser.add_argument('-f', '--file', metavar='in-file', action='store', dest='file_name', type=str, required=True, help='Name of file for which the checksum needs to be calculated')
args = parser.parse_args()
print 'Processing File ::', args.file_name
print_custom_checksum(args.file_name)