Haszowanie pliku w Pythonie

Chcę, aby Python czytał do EOF, aby uzyskać odpowiedni skrót, niezależnie od tego, czy jest to sha1 czy md5. Proszę pomóż. Oto, co mam do tej pory:

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 używają buforów, aby nie używać ton pamięci.

Myślę, że dochodzimy do sedna twojego problemu, gdy rozważymy implikacje pamięciowe pracy z bardzo dużymi plikami . Nie chcemy, aby ten zły chłopiec przerzucił 2 gigabajty pamięci RAM dla pliku o wielkości 2 gigabajtów, więc jak wskazuje pasztorpisti , musimy poradzić sobie z większymi plikami w kawałkach!

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()))

To, co zrobiliśmy, to aktualizowanie naszych skrótów tego złego chłopca w fragmentach 64kb, wraz z poręczną metodą aktualizacji hashlib . W ten sposób zużywamy o wiele mniej pamięci niż 2 GB potrzebne do zhaszowania faceta na raz!

Możesz to sprawdzić za pomocą:

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

Mam nadzieję, że to pomoże!

Wszystko to jest również opisane w powiązanym pytaniu po prawej stronie: Pobierz skrót MD5 dużych plików w Pythonie

Uzupełnienie!

Generalnie, pisząc w Pythonie, warto nabrać nawyku podążania za pep-8 . Na przykład w pythonie zmienne są zwykle oddzielane podkreśleniem, a nie camelCased. Ale to tylko styl i nikogo tak naprawdę nie obchodzą te rzeczy, z wyjątkiem ludzi, którzy muszą czytać w złym stylu ... może to być Ty czytasz ten kod za lata.

W celu prawidłowego i wydajnego obliczenia wartości skrótu pliku (w Pythonie 3):

• Otwórz plik w trybie binarnym (tj. Dodaj 'b'do trybu pliku), aby uniknąć problemów z kodowaniem znaków i konwersją końca linii.
• Nie czytaj całego pliku do pamięci, ponieważ jest to marnowanie pamięci. Zamiast tego odczytuj go sekwencyjnie blok po bloku i aktualizuj skrót dla każdego bloku.
• Wyeliminuj podwójne buforowanie, tj. Nie używaj buforowanego IO, ponieważ już używamy optymalnego rozmiaru bloku.
• Służy readinto()do zapobiegania ubijaniu buforów.

Przykład:

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()

Proponuję po prostu:

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()

Wszystkie inne odpowiedzi wydają się zbyt skomplikowane. Python już buforuje podczas odczytu (w idealny sposób lub konfigurujesz buforowanie, jeśli masz więcej informacji o podstawowej pamięci), więc lepiej jest czytać fragmentami, które funkcja skrótu uzna za idealną, co przyspiesza lub co najmniej zmniejsza obciążenie procesora oblicz funkcję skrótu. Więc zamiast wyłączać buforowanie i próbować emulować je samemu, używasz buforowania Pythona i kontrolujesz to, co powinieneś kontrolować: to, co konsument Twoich danych uważa za idealny, rozmiar bloku mieszania.

Zaprogramowałem moduł, który jest w stanie haszować duże pliki różnymi algorytmami.

pip3 install py_essentials

Użyj modułu w następujący sposób:

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

Oto Python 3, rozwiązanie POSIX (nie Windows!), Które używa mmapdo mapowania obiektu do pamięci.

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)