Existe alguma implementação de javascript SHA-256 que geralmente é considerada confiável?

Estou escrevendo um login para um fórum e preciso fazer o hash da senha do lado do cliente em javascript antes de enviá-la para o servidor. Estou tendo problemas para descobrir em qual implementação SHA-256 posso realmente confiar. Eu esperava que houvesse algum tipo de script oficial que todos usassem, mas estou encontrando vários projetos diferentes, todos com suas próprias implementações.

Sei que usar a criptografia de outras pessoas é sempre um ato de fé, a menos que você esteja qualificado para revisá-la sozinho, e que não existe uma definição universal de "confiável", mas isso parece algo comum e importante o suficiente para que haja algum tipo de consenso sobre o que usar. Eu sou apenas ingênuo?

Edite já que aparece muito nos comentários: Sim, fazemos um hash mais rigoroso novamente no lado do servidor. O hashing do lado do cliente não é o resultado final que salvamos no banco de dados. O hashing do lado do cliente ocorre porque o cliente humano o solicita. Eles não deram um motivo específico, provavelmente eles apenas gostam de exagero.

A Stanford JS Crypto Library contém uma implementação de SHA-256. Embora a criptografia em JS não seja um empreendimento tão bem avaliado quanto outras plataformas de implementação, esta é pelo menos parcialmente desenvolvida por, e até certo ponto patrocinada por, Dan Boneh , que é um nome bem estabelecido e confiável em criptografia e significa que o projeto foi supervisionado por alguém que realmente sabe o que está fazendo. O projeto também é apoiado pela NSF .

Vale a pena ressaltar, entretanto ...
... que se você hash a senha do lado do cliente antes de enviá-la, então o hash é a senha , e a senha original se torna irrelevante. Um invasor precisa apenas interceptar o hash para personificar o usuário e, se esse hash estiver armazenado sem modificações no servidor, o servidor está armazenando a senha verdadeira (o hash) em texto simples .

Portanto, sua segurança agora está pior porque você decidiu adicionar suas próprias melhorias ao que antes era um esquema confiável.

Em https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest , encontrei este snippet que usa o módulo js interno:

async function sha256(message) {
    // encode as UTF-8
    const msgBuffer = new TextEncoder('utf-8').encode(message);                    

    // hash the message
    const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);

    // convert ArrayBuffer to Array
    const hashArray = Array.from(new Uint8Array(hashBuffer));

    // convert bytes to hex string                  
    const hashHex = hashArray.map(b => ('00' + b.toString(16)).slice(-2)).join('');
    return hashHex;
}

Observe que está crypto.subtledisponível apenas em httpsou localhost- por exemplo, para o seu desenvolvimento local, python3 -m http.servervocê precisa adicionar esta linha ao seu /etc/hosts: 0.0.0.0 localhost

Reinicie - e você pode abrir localhost:8000com o trabalho crypto.subtle.

A implementação SHA-256 do Forge é rápida e confiável.

Para executar testes em várias implementações SHA-256 JavaScript, vá para http://brillout.github.io/test-javascript-hash-implementations/ .

Os resultados na minha máquina sugerem que o forge seja a implementação mais rápida e também consideravelmente mais rápida do que a Stanford Javascript Crypto Library (sjcl) mencionada na resposta aceita.

Forge tem 256 KB de tamanho, mas extrair o código relacionado ao SHA-256 reduz o tamanho para 4,5 KB, consulte https://github.com/brillout/forge-sha256

Para os interessados, este é um código para criar hash SHA-256 usando sjcl:

import sjcl from 'sjcl'

const myString = 'Hello'
const myBitArray = sjcl.hash.sha256.hash(myString)
const myHash = sjcl.codec.hex.fromBits(myBitArray)

Não, não há como usar o JavaScript do navegador para melhorar a segurança da senha. Eu recomendo fortemente que você leia este artigo . No seu caso, o maior problema é o problema do ovo da galinha:

Qual é o "problema do ovo da galinha" em fornecer criptografia Javascript?

Se você não confia na rede para fornecer uma senha ou, pior, não confia no servidor para não manter os segredos do usuário, você não pode confiar neles para fornecer o código de segurança. O mesmo invasor que estava farejando senhas ou lendo diários antes de você introduzir a criptografia está simplesmente sequestrando o código criptográfico depois de você fazer isso.

[...]

Por que não posso usar TLS / SSL para fornecer o código criptográfico Javascript?

Você pode. É mais difícil do que parece, mas você transmite criptografia Javascript com segurança para um navegador usando SSL. O problema é que, tendo estabelecido um canal seguro com SSL, você não precisa mais da criptografia Javascript; você tem criptografia "real".

O que leva a isso:

O problema com a execução de código criptográfico em Javascript é que praticamente qualquer função da qual a criptografia depende pode ser substituída silenciosamente por qualquer parte do conteúdo usado para construir a página de hospedagem. A criptografia de segurança pode ser desfeita no início do processo (gerando números aleatórios falsos ou adulterando constantes e parâmetros usados ​​por algoritmos) ou posteriormente (devolvendo o material da chave a um invasor), ou --- no cenário mais provável --- contornando a criptografia inteiramente.

Não existe uma maneira confiável para qualquer parte do código Javascript verificar seu ambiente de execução. O código criptográfico Javascript não pode perguntar: "Estou realmente lidando com um gerador de números aleatórios ou com algum fac-símile fornecido por um invasor?" E certamente não pode afirmar "ninguém tem permissão para fazer nada com este segredo criptográfico, exceto de maneiras que eu, o autor, aprovo". Essas são duas propriedades que geralmente são fornecidas em outros ambientes que usam criptografia e são impossíveis em Javascript.

Basicamente, o problema é este:

• Seus clientes não confiam em seus servidores, então eles desejam adicionar código de segurança extra.
• Esse código de segurança é fornecido por seus servidores (aqueles em que eles não confiam).

Ou alternativamente,

• Seus clientes não confiam em SSL, então eles querem que você use um código de segurança extra.
• Esse código de segurança é entregue via SSL.

Nota: Além disso, SHA-256 não é adequado para isso, já que é tão fácil usar a força bruta em senhas sem sal e não iteradas . Se você decidir fazer isso de qualquer maneira, procure uma implementação de bcrypt , scrypt ou PBKDF2 .

Achei essa implementação muito fácil de usar. Também tem uma licença generosa no estilo BSD:

jsSHA: https://github.com/Caligatio/jsSHA

Eu precisava de uma maneira rápida de obter a representação hexadecimal de um hash SHA-256. Demorou apenas 3 linhas:

var sha256 = new jsSHA('SHA-256', 'TEXT');
sha256.update(some_string_variable_to_hash);
var hash = sha256.getHash("HEX");

Além da biblioteca de Stanford que tylerl mencionou. Achei o jsrsasign muito útil ( repositório Github aqui: https://github.com/kjur/jsrsasign ). Não sei exatamente o quão confiável é, mas usei sua API de SHA256, Base64, RSA, x509 etc. e funciona muito bem. Na verdade, também inclui a biblioteca de Stanford.

Se tudo o que você deseja fazer é SHA256, jsrsasign pode ser um exagero. Mas se você tiver outras necessidades na área relacionada, acho que é uma boa opção.