SHA (Secure Hash Algorithm) é um conjunto de, até a data de escrita deste texto, 3 famílias de algoritmos criptográficos, SHA-0, SHA-1 e SHA-2. O SHA-1 produz um digest de 160 bits, baseado nos mesmos princípios dos algoritmos MD4 e MD5, de Ronald L. Rivest. Ele é uma evolução do SHA-0 que corrige uma falha do mesmo e ao mesmo tempo difere bastante do SHA-2. (Wikipedia)

Assim como o MD5, o SHA-1 é bastante utilizado para calcular checksums de arquivos. A lógica é simples: cada arquivo possui uma assinatura (checksum) que é [ou deveria ser] única. Caso o arquivo seja interceptado e modificado por terceiros, o checksum mudará, acusando o comprometimento da segurança. Apesar do SHA-1 prover 160 bits, em vez dos 128 bits do MD5, já foram detectadas colisões com ele. Isso significa que há a possibilidade de um mesmo hash ser gerado para duas entradas distintas. Por causa dessa falha de segurança já se fala em SHA-3 e algumas pessoas aconselham o uso de funções variantes do SHA-2, como SHA-256 e SHA-512, onde [ainda] não foram detectadas falhas graves.

Apesar das colisões, o SHA-1 pode garantir a segurança de muitas aplicações. Tanto que os renomados git e Mercurial o utilizam internamente para controle de versões de arquivos.

Python

No Python 3, o módulo hashlib possui a função sha1 que utiliza o SHA-1 para gerar a assinatura do parâmetro de entrada. Apesar de poder ser aplicado de uma só vez na entrada, esse procedimento pode não funcionar com entradas muito grandes, como uma imagem de CD. Isso acontece pois a função vai tentar colocar a imagem inteira na memória principal, o que pode deixar o sistema sem recursos ou fazendo uso intenso da memória virtual.

Uma técnica interessante para contornar o problema é ler o arquivo por partes e ir calculando o SHA-1 checksum de cada parte, mesclando o novo checksum com aquele já calculado. O efeito disso é o mesmo que calcular o checksum do arquivo inteiro, com a vantagem de alocar muito menos memória.

No trecho de código abaixo, é implementada a função get_sha1, que calcula SHA-1 checksums de arquivos. Como argumentos, ela recebe o caminho do arquivo a ser calculado e opcionalmente o tamanho de cada parte que será alocada na memória, com a sua métrica. O padrão é 100 KB (tamanho: 100, métrica: KB), mas pode-se usar tamanhos maiores, como 10 MB, para diminuir as iterações e ainda ter uma boa margem de segurança até o esgotamento de recursos do sistema.

import hashlib

def get_sha1(filename, size=100, metric=1):
    """Calculates and returns the filename's SHA1 Checksum.

    size defines what's the length of each part of the file.
    metric determines if each part is in KB (1), MB (2), GB
    (3) and so on.

    """

    check = hashlib.sha1()
    f = open(filename, mode='rb')
    s = 1024 ** metric * size

    while 1:  # Stops when finished reading file.
        part = f.read(s)

        if part:  # The file is over?
            check.update(part)
        else:
            break

    return check.hexdigest()

No trecho abaixo, um exemplo de uso da função get_sha1, que imprimirá na tela o SHA-1 checksum do arquivo senna.jpg.

print(get_sha1('senna.jpg'))

Shell Script

Para os adeptos de Shell Script, o procedimento é muito mais simples, pois versões mais novas das distribuições Linux costumam vir com o utilitário sha1sum – ele acompanha o Debian 6.0 e o Ubuntu 10.04, pelo menos. Sua utilização é bem simples, bastando executar o programa, passando como argumento o arquivo que deve ter a assinatura calculada.

$ sha1sum senna.jpg

Utilizado desta forma, o sha1sum vai gerar e apresentar na saída padrão o SHA-1 checksum do arquivo escolhido. Contudo, ele ainda pode ser usado para checar a integridade de arquivos mostrando o resultado explicitamente para o usuário. Note que ele gera uma saída com o seguinte padrão: . Pode-se redirecionar essa saída para um arquivo, como no exemplo abaixo:

$ sha1sum senna.jpg tiradentes.jpg > SHA1SUMS

Agora, em vez de gerar o checksum de cada arquivo e compará-los com os que haviam sido gerados, estando os arquivos senna.jpg, tiradentes.jpg e SHA1SUMS no mesmo diretório, basta executar o sha1sum com a opção -c e indicar o arquivo com os checksums, para que o programa verifique cada entrada no SHA1SUMS e mostre se houve sucesso ou falha na checagem. Isso é muito útil para verificar mais de um arquivo e evita perda de tempo ao checar manualmente se dois checksums são iguais.

$ sha1sum -c SHA1SUMS

Outra forma de se calcular SHA-1 checksums é com OpenSSL. O interessante deste método, que utiliza um kit de ferramentas Secure Socket Layer para gerar o checksum, é que ele funciona nativamente no Linux e no Mac, sendo indicado pelo próprio suporte da Apple.

Para calcular SHA-1 checksums desta forma, basta executar o openssl passando como argumentos sha1 e o caminho do arquivo, como no exemplo:

$ openssl sha1 senna.jpg

O SHA-1 é um algoritmo bastante utilizado e provê uma segurança considerável. Apesar de ser reconhecidamente falho, não é tão trivial quebrar a sua segurança explorando colisões. Isso o torna recomendável para muitas aplicações que não requerem segurança topo de linha. Mesmo assim, caso seja do desejo do usuário, pode-se utilizar algum dos algoritmos da família SHA-2, que ainda não apresentaram falhas. Com a popularização da Informática, torna-se necessário utilizar cada vez mais recursos de segurança e os SHA-1 checksums garantem confiabilidade considerável na troca de arquivos.

2 Responses to “SHA-1 Checksums”

1. RICHARD says:

   Apr 29th, 2011 at 10:41

   BOM DIA.

   MEU NOME É RICHRD E TENHO UMA EMRPESA DE REPAROS E REPROGRAMAÇÕES DE MODULOS DE INJEÇÃO ELETRONICA PARA CAMINHOES.

   ESTES MODULOS SAO PRORAMADOS PARA FAZER FUNCIONAR OS MOTORES.

   POIS BEM TEMOS UMA GRANDE DIFICULDE AQUI QUANDO PRECISAMOS CALCULAR O CHECSUN DE UM ARQUIVO , SERA QUE VOCE PODERIA NOS AJUDAR.

   GRATO. RICHARD

   Reply
   • José Lopes says:

     May 4th, 2011 at 11:34

     Claro Richard.
     Que problemas estão acontecendo?

     Reply