Dump md5 et sha1 checksums avec une seule commande!


9

Je recherche une commande ou des utilitaires pour calculer la valeur de hachage md5 , sha1 par une seule commande.
En ce moment ubuntu a sha1sumet md5sumcommande pour le calcul de la hashvaleur.


2
Pourquoi le veux tu? Généralement, vous voulez pouvoir vérifier les hachages après les avoir générés. Par exemple, pour générer un hachage: md5sum hosts. Ensuite, pour vérifier ce résultat: echo "b9adfb2e2022a3a84ba06b55eeb2dc64 hosts" | md5sum --check(devrait donner: hosts: OK)
Lekensteyn

2
Supposons que si vous voulez calculer la «valeur de hachage» d'un disque dur de 500 Go, c'est-à-dire à la fois sha1 et md5. si je calcule un par un (en utilisant sha1sum et md5sum), cela prendrait deux fois plus de temps. mais si cela pouvait être fait avec des utilitaires uniques identiques à ceux du logiciel Windows, ce serait ma réponse souhaitée.
MS Parmar

Réponses:


9

Vous pouvez y parvenir avec un bon ninja-fu bash. :)

Vous connaissez la procédure pour en calculer un à la fois:

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

Edit: comme @gertvdijk l'a suggéré, et en lisant un peu plus les pages d'informations, cela peut être fait directement avec tee et Process Substitution pris en charge par les shells modernes, sans redirection. De cette façon, vous pouvez transmettre vos données à deux processus et un fichier à l'aide de tee:

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

Il est également possible de chaîner si vous en avez besoin de plus, mais vous devez vous occuper de STDOUT de tous les sous-processus. Cela ne vous donnera PAS le résultat attendu, mais mélange les deux premières sommes de contrôle avec les données dans output.txt:

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

Si vous redirigez les sommes de contrôle vers un fichier à l'intérieur des processus substitués, vous pouvez les enchaîner comme vous le souhaitez:

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

Voici ma suggestion initiale sans substitution de processus, mais qui permet un chaînage / une utilisation récursive sans mélanger les données et la sortie:

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

L'astuce ici est d'utiliser tee, qui duplique les données sur STDOUT et un fichier. Nous sommes intelligents en lui disant d'écrire les données dans le fichier / proc / self / fd / 2, qui se trouve toujours être le descripteur de fichier STDERR du processus actuel. Et avec la > >(program)syntaxe, nous pouvons rediriger chaque descripteur de fichier vers le STDIN d'un programme au lieu d'un fichier. Tout comme |, mais avec plus de contrôle. > >(md5sum)redirige STDOUT vers le md5sumprogramme, tandis que 2> >(sha1sum)redirige STDERR vers le sha1sumprogramme.

Notez que l'ordre de 2>et >semble avoir de l'importance, je dois mettre d' 2>abord sur la ligne de commande. Ceux-ci sont évalués de droite à gauche, mais je ne sais pas pourquoi cela fait une différence.

Pour ce faire sur un fichier ou un disque dur, vous devez remplacer "echo abc" par un chat ou un dd, par exemple:

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

La chose astucieuse à ce sujet est que vous pouvez réellement récurrer et exécuter plusieurs en même temps, pas seulement deux. La syntaxe devient poilue, mais cela fonctionne:

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

Si vous souhaitez capturer le résultat et l'utiliser dans un script, cela fonctionne aussi:

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

$AEst maintenant une chaîne contenant toutes les sorties, y compris les retours à la ligne. Vous pouvez également analyser les valeurs plus tard:

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

Je ne suis pas sûr que vous ayez cependant des garanties concernant la commande de la sortie.


2
+1. teeet l'utilisation intelligente de la redirection de sortie dans le shell est la voie à suivre. Cela économise beaucoup de ressources, en particulier lors de la lecture de fichiers volumineux.
gertvdijk

2
Soit dit en passant, je pense que vous n'avez pas besoin de rediriger vers stderr pour dupliquer la sortie du flux. L'utilisation d'un sous-shell fera également l'affaire, en maintenant stderr. Voir mon exemple ici dans un article de blog .
gertvdijk

@gertvdijk À droite, la substitution de processus est plus propre et plus facile à enchaîner (vous n'avez pas besoin de recurse). Je mettrai à jour ma réponse.
ketil

Agréable. Je vous donnerais un autre vote positif si je le pouvais. :-)
gertvdijk

Bien que ceux-ci fonctionnent bien pour les petits fichiers sympas, vous doublez les efforts et le temps de traitement pour les fichiers plus gros que je cherche à éviter ...
EkriirkE

3

Je ne peux pas vous aider avec la ligne de commande mais je connais un outil GUI nommé quickhash.

Vous pouvez télécharger cet outil depuis Quickhash

La description:

Une interface graphique Linux et Windows pour permettre la sélection rapide et le hachage ultérieur des fichiers (individuellement ou récursivement dans une structure de dossiers) et des disques (sous Linux). Conçu pour Linux, mais également disponible pour Windows. MD5, SHA1, SHA256, SHA512 disponibles. Sortie copiée dans le presse-papiers ou enregistrée au format CSV \ HTML.


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

// Début du script à partir d'ici

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 'SHA1s' '] print' Stop Time :: ', custom_checksum_profile [' stoptime '] print' Processing Time :: ', custom_checksum_profile [' processtime '] sauf TypeError: # L'objet' NoneType 'n'est pas indcriptible --- en gros, cela devrait se produire lorsque le le fichier d'entrée n'a pas pu être ouvert # passe passe # sortie csv

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)
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.