Hashing di un file in Python

Voglio che Python legga in EOF in modo da poter ottenere un hash appropriato, che sia sha1 o md5. Per favore aiuto. Ecco cosa ho finora:

import hashlib

inputFile = raw_input("Enter the name of the file:")
openedFile = open(inputFile)
readFile = openedFile.read()

md5Hash = hashlib.md5(readFile)
md5Hashed = md5Hash.hexdigest()

sha1Hash = hashlib.sha1(readFile)
sha1Hashed = sha1Hash.hexdigest()

print "File Name: %s" % inputFile
print "MD5: %r" % md5Hashed
print "SHA1: %r" % sha1Hashed

TL; DR utilizza buffer per non utilizzare tonnellate di memoria.

Arriviamo al nocciolo del tuo problema, credo, quando consideriamo le implicazioni sulla memoria del lavoro con file molto grandi . Non vogliamo che questo ragazzaccio sbandieri 2 giga di ram per un file da 2 gigabyte quindi, come fa notare pasztorpisti , dobbiamo occuparci di quei file più grandi in pezzi!

import sys
import hashlib

# BUF_SIZE is totally arbitrary, change for your app!
BUF_SIZE = 65536  # lets read stuff in 64kb chunks!

md5 = hashlib.md5()
sha1 = hashlib.sha1()

with open(sys.argv[1], 'rb') as f:
    while True:
        data = f.read(BUF_SIZE)
        if not data:
            break
        md5.update(data)
        sha1.update(data)

print("MD5: {0}".format(md5.hexdigest()))
print("SHA1: {0}".format(sha1.hexdigest()))

Quello che abbiamo fatto è che stiamo aggiornando i nostri hash di questo ragazzaccio in blocchi da 64kb mentre procediamo con il pratico metodo di aggiornamento dandy di hashlib . In questo modo usiamo molta meno memoria rispetto ai 2 GB necessari per hash il ragazzo tutto in una volta!

Puoi testarlo con:

$ mkfile 2g bigfile
$ python hashes.py bigfile
MD5: a981130cf2b7e09f4686dc273cf7187e
SHA1: 91d50642dd930e9542c39d36f0516d45f4e1af0d
$ md5 bigfile
MD5 (bigfile) = a981130cf2b7e09f4686dc273cf7187e
$ shasum bigfile
91d50642dd930e9542c39d36f0516d45f4e1af0d  bigfile

Spero che aiuti!

Anche tutto questo è delineato nella domanda collegata sul lato destro: Ottieni l'hash MD5 di file di grandi dimensioni in Python

Addendum!

In generale, quando si scrive python è utile prendere l'abitudine di seguire pep-8 . Ad esempio, in Python le variabili sono in genere separate da caratteri di sottolineatura non camelCased. Ma questo è solo stile e nessuno si preoccupa davvero di queste cose tranne le persone che devono leggere uno stile cattivo ... che potresti leggere questo codice tra anni.

Per il calcolo corretto ed efficiente del valore hash di un file (in Python 3):

• Aprire il file in modalità binaria (ovvero aggiungerlo 'b'alla modalità file ) per evitare problemi di codifica dei caratteri e conversione di fine riga.
• Non leggere il file completo in memoria, poiché è uno spreco di memoria. Invece, leggilo in sequenza blocco per blocco e aggiorna l'hash per ogni blocco.
• Elimina il doppio buffering, ovvero non utilizzare l'IO bufferizzato, perché utilizziamo già una dimensione di blocco ottimale.
• Da utilizzare readinto()per evitare il ribaltamento del buffer.

Esempio:

import hashlib

def sha256sum(filename):
    h  = hashlib.sha256()
    b  = bytearray(128*1024)
    mv = memoryview(b)
    with open(filename, 'rb', buffering=0) as f:
        for n in iter(lambda : f.readinto(mv), 0):
            h.update(mv[:n])
    return h.hexdigest()

Proporrei semplicemente:

def get_digest(file_path):
    h = hashlib.sha256()

    with open(file_path, 'rb') as file:
        while True:
            # Reading is buffered, so we can read smaller chunks.
            chunk = file.read(h.block_size)
            if not chunk:
                break
            h.update(chunk)

    return h.hexdigest()

Tutte le altre risposte qui sembrano complicare troppo. Python sta già eseguendo il buffering durante la lettura (in modo ideale, o lo configuri se hai più informazioni sullo storage sottostante) e quindi è meglio leggere in blocchi la funzione hash trova l'ideale che lo rende più veloce o almeno meno intensivo della CPU per calcolare la funzione hash. Quindi, invece di disabilitare il buffering e provare a emularlo da solo, usi il buffering Python e controlli ciò che dovresti controllare: ciò che il consumatore dei tuoi dati trova ideale, la dimensione del blocco hash.

Ho programmato un modulo che è in grado di eseguire l'hashing di file di grandi dimensioni con diversi algoritmi.

pip3 install py_essentials

Usa il modulo in questo modo:

from py_essentials import hashing as hs
hash = hs.fileChecksum("path/to/the/file.txt", "sha256")

Ecco una soluzione Python 3, POSIX (non Windows!) Che utilizza mmapper mappare l'oggetto in memoria.

import hashlib
import mmap

def sha256sum(filename):
    h  = hashlib.sha256()
    with open(filename, 'rb') as f:
        with mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ) as mm:
            h.update(mm)
    return h.hexdigest()

import hashlib
user = input("Enter ")
h = hashlib.md5(user.encode())
h2 = h.hexdigest()
with open("encrypted.txt","w") as e:
    print(h2,file=e)


with open("encrypted.txt","r") as e:
    p = e.readline().strip()
    print(p)