Gerando uma soma de verificação MD5 de um arquivo

Existe alguma maneira simples de gerar (e verificar) somas de verificação MD5 de uma lista de arquivos em Python? (Eu tenho um pequeno programa em que estou trabalhando e gostaria de confirmar as somas de verificação dos arquivos).

Você pode usar hashlib.md5 ()

Observe que, às vezes, você não poderá ajustar o arquivo inteiro na memória. Nesse caso, você terá que ler trechos de 4096 bytes sequencialmente e alimentá-los com o md5método:

import hashlib
def md5(fname):
    hash_md5 = hashlib.md5()
    with open(fname, "rb") as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_md5.update(chunk)
    return hash_md5.hexdigest()

Nota: hash_md5.hexdigest() retornará a representação de sequência hexadecimal para o resumo, se você precisar apenas dos bytes compactados return hash_md5.digest(), para que não precise converter novamente.

Existe uma maneira que é bastante ineficiente de memória .

único arquivo:

import hashlib
def file_as_bytes(file):
    with file:
        return file.read()

print hashlib.md5(file_as_bytes(open(full_path, 'rb'))).hexdigest()

lista de arquivos:

[(fname, hashlib.md5(file_as_bytes(open(fname, 'rb'))).digest()) for fname in fnamelst]

Lembre-se, porém, que o MD5 é conhecido como quebrado e não deve ser usado para nenhuma finalidade, pois a análise de vulnerabilidade pode ser realmente complicada, e é impossível analisar qualquer possível uso futuro ao qual seu código possa ser usado para problemas de segurança. IMHO, ele deve ser totalmente removido da biblioteca para que todos que o usem sejam forçados a atualizar. Então, aqui está o que você deve fazer:

[(fname, hashlib.sha256(file_as_bytes(open(fname, 'rb'))).digest()) for fname in fnamelst]

Se você quiser apenas 128 bits de resumo, você pode fazer .digest()[:16].

Isso fornecerá uma lista de tuplas, cada uma contendo o nome de seu arquivo e seu hash.

Novamente, questiono fortemente o uso do MD5. Você deve pelo menos usar o SHA1 e, dadas as falhas recentes descobertas no SHA1 , provavelmente nem isso. Algumas pessoas pensam que, desde que você não esteja usando o MD5 para fins 'criptográficos', você estará bem. Mas as coisas tendem a acabar tendo um escopo mais amplo do que o esperado inicialmente, e sua análise de vulnerabilidade casual pode ser completamente falha. É melhor simplesmente adquirir o hábito de usar o algoritmo certo imediatamente. É só digitar um monte diferente de letras. Não é tão difícil.

Aqui está uma maneira mais complexa, mas eficiente em termos de memória :

import hashlib

def hash_bytestr_iter(bytesiter, hasher, ashexstr=False):
    for block in bytesiter:
        hasher.update(block)
    return hasher.hexdigest() if ashexstr else hasher.digest()

def file_as_blockiter(afile, blocksize=65536):
    with afile:
        block = afile.read(blocksize)
        while len(block) > 0:
            yield block
            block = afile.read(blocksize)


[(fname, hash_bytestr_iter(file_as_blockiter(open(fname, 'rb')), hashlib.md5()))
    for fname in fnamelst]

E, novamente, como o MD5 está quebrado e realmente não deve mais ser usado:

[(fname, hash_bytestr_iter(file_as_blockiter(open(fname, 'rb')), hashlib.sha256()))
    for fname in fnamelst]

Mais uma vez, você pode fazer [:16]a chamada depois hash_bytestr_iter(...)se quiser apenas 128 bits digeridos.

Claramente, não estou adicionando nada fundamentalmente novo, mas adicionei esta resposta antes de comentar o status, além das regiões de código tornarem as coisas mais claras - de qualquer maneira, especificamente para responder à pergunta de @ Nemo da resposta de Omnifarious:

Por acaso, pensei um pouco sobre as somas de verificação (vim aqui procurando sugestões sobre tamanhos de bloco, especificamente) e descobri que esse método pode ser mais rápido do que você esperaria. Tomando o mais rápido (mas bastante típico) timeit.timeitou /usr/bin/timeresultado de cada um dos vários métodos de checksum um arquivo de aprox. 11MB:

$ ./sum_methods.py
crc32_mmap(filename) 0.0241742134094
crc32_read(filename) 0.0219960212708
subprocess.check_output(['cksum', filename]) 0.0553209781647
md5sum_mmap(filename) 0.0286180973053
md5sum_read(filename) 0.0311000347137
subprocess.check_output(['md5sum', filename]) 0.0332629680634
$ time md5sum /tmp/test.data.300k
d3fe3d5d4c2460b5daacc30c6efbc77f  /tmp/test.data.300k

real    0m0.043s
user    0m0.032s
sys     0m0.010s
$ stat -c '%s' /tmp/test.data.300k
11890400

Portanto, parece que o Python e / usr / bin / md5sum levam cerca de 30ms para um arquivo de 11MB. A md5sumfunção relevante ( md5sum_readna lista acima) é bastante semelhante à Omnifarious:

import hashlib
def md5sum(filename, blocksize=65536):
    hash = hashlib.md5()
    with open(filename, "rb") as f:
        for block in iter(lambda: f.read(blocksize), b""):
            hash.update(block)
    return hash.hexdigest()

É verdade que estas são de execuções únicas ( mmapas que são sempre um pouco mais rápidas quando são feitas pelo menos algumas dúzias de execuções), e as minhas geralmente recebem um extra f.read(blocksize)depois que o buffer é esgotado, mas é razoavelmente repetível e mostra que md5sumna linha de comando está não necessariamente mais rápido que uma implementação em Python ...

EDIT: Desculpe pelo longo atraso, não olhei para isso há algum tempo, mas para responder à pergunta de @ EdRandall, vou escrever uma implementação do Adler32. No entanto, eu não corri os parâmetros para isso. É basicamente o mesmo que o CRC32 teria sido: em vez das chamadas init, update e digest, tudo é uma zlib.adler32()chamada:

import zlib
def adler32sum(filename, blocksize=65536):
    checksum = zlib.adler32("")
    with open(filename, "rb") as f:
        for block in iter(lambda: f.read(blocksize), b""):
            checksum = zlib.adler32(block, checksum)
    return checksum & 0xffffffff

Observe que isso deve começar com a string vazia, pois as somas de Adler realmente diferem quando se inicia do zero em relação à sua soma para "", que é 1- o CRC pode começar com 0ele. O AND-ing é necessário para torná-lo um número inteiro não assinado de 32 bits, o que garante que ele retorne o mesmo valor nas versões do Python.

No Python 3.8 ou superior, você pode fazer

import hashlib
with open("your_filename.txt", "rb") as f:
    file_hash = hashlib.md5()
    while chunk := f.read(8192):
        file_hash.update(chunk)

print(file_hash.digest())
print(file_hash.hexdigest())  # to get a printable str instead of bytes

Considere usar em hashlib.blake2bvez de md5(basta substituí md5-lo blake2bno snippet acima). É criptograficamente seguro e mais rápido que o MD5.

hashlib.md5(pathlib.Path('path/to/file').read_bytes()).hexdigest()

Eu acho que confiar no invoke package e no md5sum binário é um pouco mais conveniente do que o subprocesso ou o pacote md5

import invoke

def get_file_hash(path):

    return invoke.Context().run("md5sum {}".format(path), hide=True).stdout.split(" ")[0]

Obviamente, isso pressupõe que você invocou e md5sum instalado.