Gerar hash SHA-1

O Google e o CWI de Amsterdã publicaram dois PDF diferentes com o mesmo SHA-1. Custou cerca de 6.500 anos de CPU em paralelo, e desde então o preço só caiu: hoje é questão de algumas dezenas de milhares de dólares em computação alugada.

O que isso destrói é a capacidade de afirmar que um conteúdo não mudou diante de alguém capaz de fabricar o outro. Assinatura, certificado e verificação de integridade com adversário estão fora. O que isso não destrói é a resistência à pré-imagem: continua não havendo jeito prático de recuperar o texto original.

Um identificador de objeto do Git é um SHA-1, e mudar isso significa mudar o formato de repositório de todo mundo ao mesmo tempo. Existe uma transição para SHA-256 especificada e em andamento há anos, e ela avança devagar exatamente por isso.

Enquanto isso, o Git aplica uma detecção de colisão que reconhece os padrões do ataque conhecido e recusa esses objetos. Isso não torna o SHA-1 seguro; fecha a via concreta que foi demonstrada. Se isso basta depende de quem consegue colocar conteúdo dentro do seu repositório.

Volta e meia aparece a ideia de aplicar SHA-1 duas vezes, combinar com um sal ou encadear dois algoritmos. Nada disso conserta uma fraqueza de colisão: duas entradas que coincidem na primeira passada coincidem também na segunda, porque a segunda só enxerga o resultado da primeira.

Para resistência a colisão, a única coisa que funciona é outro algoritmo. Além disso, construções caseiras não são analisadas e às vezes se comportam pior do que as peças delas — há um motivo para o HMAC ser um desenho cuidadoso e não simplesmente um hash sobre a chave e a mensagem coladas.

O Git mostra identificadores abreviados, tradicionalmente com sete caracteres. São 28 bits, cerca de 268 milhões de possibilidades, e pelo paradoxo do aniversário as colisões ficam prováveis quando um repositório se aproxima de uns 16 mil objetos. Um projeto médio chega lá sem esforço.

O Git resolve alongando a forma curta automaticamente quando precisa, e por isso em repositórios grandes se veem oito, nove ou dez caracteres. Quem copiar um identificador abreviado para um script ou para um chamado deveria saber disso: é um auxílio visual, não um identificador estável.

O SHA-1 são 160 bits escritos como 40 dígitos hexadecimais, sempre com o mesmo comprimento. Junto com os 32 do MD5 e os 64 do SHA-256, isso permite reconhecer de relance com o que se está lidando.

É uma conferência que economiza tempo quando uma documentação antiga diz só «hash». Contar os caracteres responde a pergunta antes de ler o resto do documento, e evita comparar valores produzidos por algoritmos diferentes.

O Git coloca na frente de cada objeto o tipo e o comprimento dele, separados por um byte zero, e gera o hash disso. O SHA-1 do conteúdo puro de um arquivo não é, portanto, o identificador de objeto dele — um resultado que é confundido com erro com bastante frequência e não é.

Quem quiser reproduzir um identificador na mão precisa montar esse cabeçalho antes. Esta página gera o hash do texto que você entregar, sem enfeite, que é o que se precisa quando o que está sendo reproduzido é uma assinatura antiga ou o valor esperado por uma integração legada.

Igual aos outros dois: uma ferramenta Unix escreve uma quebra de linha no fim de um arquivo e um campo de texto não escreve, então o `sha1sum` de um arquivo com uma palavra não bate com o SHA-1 dessa palavra digitada aqui.

Isso se repete nas três páginas porque é o motivo mais frequente de dois valores não fecharem, e porque quem chega a uma delas raramente leu as outras duas. Um byte invisível que muda o resultado inteiro merece ser dito toda vez.

Os navegadores pararam de aceitar certificados TLS assinados com SHA-1 no começo de 2017, e as autoridades certificadoras pararam de emiti-los antes disso. Se um serviço interno ainda apresenta um, o sintoma não é um aviso e sim uma recusa: o navegador não abre.

A solução nesse caso nunca é o cliente e sim o servidor. Reemitir o certificado com SHA-256 é uma operação de minutos, e o motivo de isso ainda aparecer costuma ser um equipamento de rede ou uma autoridade interna que ninguém atualiza desde antes de 2017.

A autenticação em dois fatores por aplicativo — os seis dígitos que mudam a cada trinta segundos — usa HMAC-SHA1 por padrão na especificação do TOTP. Isso surpreende quem sabe que o SHA-1 está quebrado, e não é contradição: o ataque conhecido é de colisão, e o HMAC não depende de resistência a colisão.

A regra prática que sai daí é a mesma da página do MD5. Encontrar HMAC-SHA1 num protocolo existente não é motivo de alarme; escolher SHA-1 puro para validar alguma coisa nova é. As duas situações se parecem de fora e são opostas por dentro.

Use se algo externo exigir e você não puder mudar: um identificador do Git, uma integração com um sistema antigo, um formato de arquivo definido há vinte anos. Nesses casos a alternativa não é SHA-256, a alternativa é não conversar com o outro lado.

Não escolha para nada novo. Se você está decidindo hoje como assinar, como verificar integridade ou como gerar um identificador, o SHA-256 faz o mesmo trabalho sem a dívida — e não existe vantagem do SHA-1 que compense arrastá-la.

Um SHA-1 são 160 bits, ou seja vinte bytes. Escrito em hexadecimal ele ocupa quarenta caracteres, e é assim que ele quase sempre acaba guardado — numa coluna de texto, com o dobro do espaço necessário e um índice do dobro do tamanho.

Numa tabela pequena isso não importa; num índice com dezenas de milhões de linhas, importa. A alternativa é uma coluna binária de vinte bytes, e o custo dela é que o valor deixa de ser legível numa consulta manual. É uma troca consciente, e a hora de fazê-la é antes de a tabela existir, porque mudar o tipo de uma coluna indexada depois é uma migração cara.

O que passa por um campo desses costuma vir de dado real: um valor de uma linha, um identificador de integração, um conteúdo que precisa fechar com um sistema antigo. Como a conta acontece na página, nada disso é compartilhado conosco.

E, como nas outras duas: gerar hash de um dado pessoal não o anonimiza quando o conjunto de entradas é limitado. Com SHA-1 isso vale em dobro, porque a velocidade dele torna testar candidatos ainda mais barato do que com SHA-256.