Scarica md5 e sha1 checksum con un solo comando!

Sto cercando il comando o le utilità per il calcolo del valore hash md5 , sha1 da un comando.
In questo momento Ubuntu ha sha1sume il md5sumcomando per il calcolo del hashvalore.

Puoi ottenerlo con un vero ninja-fu bash. :)

Conosci la procedura per calcolarne uno alla volta:

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

Modifica: come suggerito da @gertvdijk, e leggendo un po 'di più le pagine informative, questo può essere fatto direttamente con la sostituzione di T e Process supportata da moderne shell, senza reindirizzamenti. In questo modo puoi passare i tuoi dati a due processi e un file usando tee:

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

È anche possibile concatenare se ne hai bisogno di più, ma devi occuparti di STDOUT da tutti i sottoprocessi. Questo NON ti darà il risultato atteso, ma mescola i primi due checksum con i dati in output.txt:

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

Se reindirizzi i checksum su un file all'interno dei processi sostituiti, puoi concatenarli come preferisci:

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

Ecco il mio suggerimento iniziale senza sostituzione del processo, ma che consente l'uso concatenato / ricorsivo senza mescolare i dati e l'output:

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

Il trucco qui è usare tee, che duplica i dati in STDOUT e in un file. Siamo stati intelligenti dicendogli di scrivere i dati nel file / proc / self / fd / 2, che risulta essere sempre il descrittore di file STDERR del processo corrente. E con la > >(program)sintassi possiamo reindirizzare ogni descrittore di file allo STDIN di un programma anziché a un file. Proprio come |, ma con un maggiore controllo. > >(md5sum)reindirizza STDOUT al md5sumprogramma, mentre 2> >(sha1sum)reindirizza STDERR al sha1sumprogramma.

Si noti che l'ordine 2>e >sembra importare, devo 2>prima inserirmi nella riga di comando. Questi sono valutati da destra a sinistra, ma non sono sicuro del perché questo faccia la differenza.

Per fare questo su un file o un disco rigido, è necessario sostituire "echo abc" con un gatto o un dd, ad esempio:

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

La cosa bella di questo è che puoi effettivamente ricorrere ed eseguirne diversi contemporaneamente, non solo due. La sintassi diventa pelosa, ma funziona:

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

Se vuoi catturare il risultato e usarlo in uno script, funziona anche:

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

Ora $Aè una stringa che contiene tutto l'output, comprese le nuove righe. Puoi anche analizzare i valori in un secondo momento:

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

Tuttavia, non sono sicuro che tu abbia alcuna garanzia riguardo all'ordinamento dell'output.

Non posso aiutarti con la riga di comando ma conosco uno strumento GUI chiamato quickhash.

Puoi scaricare quello strumento da Quickhash

Descrizione:

Una GUI di Linux e Windows per consentire la selezione rapida e il successivo hash dei file (individualmente o in modo ricorsivo in una struttura di cartelle) di testo e (su Linux). Progettato per Linux, ma disponibile anche per Windows. MD5, SHA1, SHA256, SHA512 disponibili. Output copiato negli Appunti o salvato come file CSV \ HTML.

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.

// Lo script inizia da qui

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']) # print ('Last Chunk (bytes):', custom_checksum_profile ['last_chunk_size']) print 'MD5 ::', custom_checksum_profile ['md5_checksum'] print 'SHAecksum' ',' ' '] print' Stop Time :: ', custom_checksum_profile [' stoptime '] print' Processing Time :: ', custom_checksum_profile [' processtime '] tranne TypeError: # L'oggetto' NoneType 'non è sottoscrivibile --- sostanzialmente questo dovrebbe accadere quando l'oggetto impossibile aprire il file di input #raise pass # csv output

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)