Calcola contemporaneamente più digest (md5, sha256)?

Partendo dal presupposto che l'I / O del disco e la RAM libera sono un collo di bottiglia (mentre il tempo della CPU non è la limitazione), esiste uno strumento in grado di calcolare più digest di messaggi contemporaneamente?

Sono particolarmente interessato a calcolare i digest MD-5 e SHA-256 di file di grandi dimensioni (dimensioni in gigabyte), preferibilmente in parallelo. Ho provato openssl dgst -sha256 -md5, ma calcola solo l'hash usando un algoritmo.

Pseudo-codice per il comportamento previsto:

for each block:
    for each algorithm:
        hash_state[algorithm].update(block)
for each algorithm:
    print algorithm, hash_state[algorithm].final_hash()

Scopri pee(" tee standard input to pipes") da moreutils. Questo è sostanzialmente equivalente al teecomando di Marco , ma un po 'più semplice da digitare.

$ echo foo | pee md5sum sha256sum
d3b07384d113edec49eaa6238ad5ff00  -
b5bb9d8014a0f9b1d61e21e796d78dccdf1352f23cd32812f4850b878ae4944c  -

$ pee md5sum sha256sum <foo.iso
f109ffd6612e36e0fc1597eda65e9cf0  -
469a38cb785f8d47a0f85f968feff0be1d6f9398e353496ff7aa9055725bc63e  -

È possibile utilizzare un forciclo per eseguire il ciclo sui singoli file e quindi utilizzare in tee combinazione con la sostituzione del processo (funziona in Bash e Zsh tra gli altri) per eseguire il pipe a diversi checksum.

Esempio:

for file in *.mkv; do
  tee < "$file" >(sha256sum) | md5sum
done

Puoi anche usare più di due checksum:

for file in *.mkv; do
  tee < "$file" >(sha256sum) >(sha384sum) | md5sum
done

Questo ha lo svantaggio che i checksum non conoscono il nome del file, perché viene passato come input standard. Se ciò non è accettabile, devi emettere manualmente i nomi dei file. Esempio completo:

for file in *.mkv; do
  echo "$file"
  tee < "$file" >(sha256sum) >(sha384sum) | md5sum
  echo
done > hashfilelist

È un peccato che l'utilità openssl non accetti più comandi digest; Immagino che eseguire lo stesso comando su più file sia un modello di uso più comune. FWIW, la versione dell'utility openssl sul mio sistema (Mepis 11) ha solo comandi per sha e sha1, non per nessuna delle altre varianti sha. Ma ho un programma chiamato sha256sum e md5sum.

Ecco un semplice programma Python, dual_hash.py, che fa quello che vuoi. Una dimensione del blocco di 64k sembra essere ottimale per la mia macchina (Intel Pentium 4 2.00GHz con 2G di RAM), YMMV. Per file di piccole dimensioni, la sua velocità è all'incirca la stessa di eseguire md5sum e sha256sum in successione. Ma per file più grandi è significativamente più veloce. Ad esempio, su un file 1967063040 byte (un'immagine disco di una scheda SD piena di file mp3), md5sum + sha256sum richiede circa 1m44.9s, dual_hash.py richiede 1m0.312s.

dual_hash.py

#! /usr/bin/env python

''' Calculate MD5 and SHA-256 digests of a file simultaneously

    Written by PM 2Ring 2014.10.23
'''

import sys
import hashlib

def digests(fname, blocksize):
    md5 = hashlib.md5()
    sha = hashlib.sha256()
    with open(fname, 'rb') as f:
        while True:
            block = f.read(blocksize)
            if not block:
                break
            md5.update(block)
            sha.update(block)

    print("md5: %s" % md5.hexdigest())
    print("sha256: %s" % sha.hexdigest())

def main(*argv):
    blocksize = 1<<16 # 64kB
    if len(argv) < 2:
        print("No filename given!\n")
        print("Calculate md5 and sha-256 message digests of a file.")
        print("Usage:\npython %s filename [blocksize]\n" % sys.argv[0])
        print("Default blocksize=%d" % blocksize)
        return 1

    fname = argv[1]

    if len(argv) > 2:
        blocksize = int(sys.argv[2])

    print("Calculating MD5 and SHA-256 digests of %r using a blocksize of %d" % (fname, blocksize))
    digests(fname, blocksize)

if __name__ == '__main__':
    sys.exit(main(*sys.argv))

Suppongo che una versione C / C ++ di questo programma sarebbe un po 'più veloce, ma non molto, dal momento che gran parte del lavoro viene svolto dal modulo hashlib, che è scritto in C (o C ++). E come hai notato sopra, il collo di bottiglia per file di grandi dimensioni è la velocità IO.

Puoi sempre usare qualcosa come GNU parallel :

echo "/path/to/file" | parallel 'md5sum {} & sha256sum {}'

In alternativa, esegui uno dei due in background:

md5sum /path/to/file & sha256sum /path/to/file

Oppure, salvare l'output in file diversi ed eseguire più processi in background:

for file in *; do
    md5sum "$file" > "$file".md5 &
    sha256sum "$file" > "$file".sha &
done

Che lancerà il maggior numero md5sume sha256sumle istanze, come si dispone di file e saranno tutti in parallelo, salvando la loro produzione ai nomi dei file corrispondenti. Attenzione però, questo può diventare pesante se hai molti file.

Per curiosità se uno script multi-threaded Python ridurrebbe il tempo di esecuzione, ho creato questo digest.pyscript che usi threading.Thread, threading.Queueehashlib per calcolare gli hash per più file.

L'implementazione multi-thread di Python è in effetti leggermente più veloce rispetto all'uso peecon coreutils. Java d'altra parte è ... meh. I risultati sono disponibili in questo messaggio di commit :

Per confronto, per un file di 2,3 GiB (min / avg / max / sd sec per n = 10):

• pee sha256sum md5sum <file: 16.5 / 16.9 /17.4/.305
• python3 digest.py -sha256 -md5 <file: 13.7 / 15.0 /18.7/1.77
• python2 digest.py -sha256 -md5 <file: 13.7 / 15.9 /18.7/1.64
• jacksum -a sha256 + md5 -F '#CHECKSUM {i} #FILENAME': 32.7 / 37.1 /50/6.91

L'output hash è compatibile con l'output prodotto da coreutils. Poiché la lunghezza dipende dall'algoritmo di hashing, questo strumento non lo stampa. Utilizzo (per confronto, è peestato anche aggiunto):

$ ./digest.py -sha256 -md5 digest.py
c217e5aa3c3f9cfaca0d40b1060f6233297a3a0d2728dd19f1de3b28454975f2  digest.py
b575edf6387888a68c93bf89291f611c  digest.py
$ ./digest.py -sha256 -md5 <digest.py
c217e5aa3c3f9cfaca0d40b1060f6233297a3a0d2728dd19f1de3b28454975f2  -
b575edf6387888a68c93bf89291f611c  -
$ pee sha256sum md5sum <digest.py
c217e5aa3c3f9cfaca0d40b1060f6233297a3a0d2728dd19f1de3b28454975f2  -
b575edf6387888a68c93bf89291f611c  -

Jacksum è un'utilità gratuita e indipendente dalla piattaforma per il calcolo e la verifica di checksum, CRC e hash (digest dei messaggi) nonché timestamp di file. (estratto dalla pagina man di jacksum )

È in grado di riconoscere file di grandi dimensioni, è in grado di elaborare file di dimensioni fino a 8 Exabyte (= 8.000.000.000 di Gigabyte), presupponendo che il sistema operativo in uso sia compatibile anche con i file system. (estratto da http://www.jonelo.de/java/jacksum/ )

Esempio di utilizzo:

jacksum -a md5+sha256 -F "#ALGONAME{i} (#FILENAME) = #CHECKSUM{i}" jacksum-testfile

Uscita campione:

md5 (jacksum-testfile) = d41d8cd98f00b204e9800998ecf8427e
sha256 (jacksum-testfile) = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

Su Ubuntu, esegui il comando apt-get install jacksum per ottenerlo.

In alternativa, i codici sorgente sono disponibili all'indirizzo

• http://www.jonelo.de/java/jacksum/#Download
• http://sourceforge.net/projects/jacksum/