Hash de um arquivo em Python

Quero que o python leia o EOF para que eu possa obter um hash apropriado, seja sha1 ou md5. Por favor ajude. Aqui está o que tenho até agora:

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 usam buffers para não usar toneladas de memória.

Chegamos ao cerne do seu problema, acredito, quando consideramos as implicações de memória de trabalhar com arquivos muito grandes . Não queremos que esse bad boy misture 2 GB de RAM por um arquivo de 2 GB, então, como pasztorpisti aponta, temos que lidar com esses arquivos maiores em pedaços!

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

O que fizemos foi atualizar nossos hashes desse bad boy em pedaços de 64kb conforme seguimos com o prático método de atualização dândi do hashlib . Dessa forma, usamos muito menos memória do que os 2 GB que seriam necessários para fazer o hash do cara de uma vez!

Você pode testar isso com:

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

Espero que ajude!

Além disso, tudo isso é descrito na pergunta vinculada no lado direito: Obtenha hash MD5 de arquivos grandes em Python

Termo aditivo!

Em geral, ao escrever python, ajuda a adquirir o hábito de seguir o pep-8 . Por exemplo, em Python, as variáveis ​​são normalmente separadas por sublinhado e não por camelCased. Mas isso é apenas estilo e ninguém realmente se preocupa com essas coisas, exceto as pessoas que têm que ler um estilo ruim ... que pode ser você lendo este código daqui a alguns anos.

Para o cálculo correto e eficiente do valor hash de um arquivo (em Python 3):

• Abra o arquivo no modo binário (ou seja, adicione 'b'ao modo de arquivo) para evitar problemas de codificação de caracteres e conversão de final de linha.
• Não leia o arquivo completo na memória, pois isso é um desperdício de memória. Em vez disso, leia sequencialmente bloco por bloco e atualize o hash para cada bloco.
• Elimine o buffer duplo, ou seja, não use IO com buffer, porque já usamos um tamanho de bloco ideal.
• Use readinto()para evitar agitação do buffer.

Exemplo:

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

Eu proporia simplesmente:

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

Todas as outras respostas aqui parecem complicar muito. Python já está armazenando em buffer durante a leitura (de maneira ideal, ou você configura esse armazenamento em buffer se tiver mais informações sobre o armazenamento subjacente) e por isso é melhor ler em partes que a função hash considera ideal, o que a torna mais rápida ou pelo menos menos intensiva de CPU para calcule a função hash. Portanto, em vez de desabilitar o buffer e tentar emular você mesmo, você usa o buffer do Python e controla o que deveria estar controlando: o que o consumidor de seus dados acha ideal, o tamanho do bloco hash.

Programei um módulo capaz de fazer hash de arquivos grandes com diferentes algoritmos.

pip3 install py_essentials

Use o módulo assim:

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

Aqui está um Python 3, solução POSIX (não Windows!) Que usa mmappara mapear o objeto na memória.

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)