¿Existe alguna implementación de javascript SHA-256 que generalmente se considere confiable?

Estoy escribiendo un inicio de sesión para un foro y necesito codificar la contraseña del lado del cliente en javascript antes de enviarla al servidor. Tengo problemas para averiguar en qué implementación de SHA-256 realmente puedo confiar. Esperaba que hubiera algún tipo de script autorizado que todos usaran, pero estoy encontrando muchos proyectos diferentes, todos con sus propias implementaciones.

Me doy cuenta de que usar las criptomonedas de otras personas es siempre un acto de fe a menos que esté calificado para revisarlo usted mismo, y que no existe una definición universal de "confiable", pero esto parece algo común y lo suficientemente importante como para que haya algún tipo de de consenso sobre qué utilizar. ¿Soy simplemente ingenuo?

Edite ya que aparece mucho en los comentarios: Sí, volvemos a hacer un hash más estricto en el lado del servidor. El hash del lado del cliente no es el resultado final que guardamos en la base de datos. El hash del lado del cliente se debe a que el cliente humano lo solicita. No han dado una razón específica por la cual, probablemente solo les gusta la exageración.

La biblioteca de cifrado de Stanford JS contiene una implementación de SHA-256. Si bien la criptografía en JS no es un esfuerzo tan bien investigado como otras plataformas de implementación, esta está al menos parcialmente desarrollada y hasta cierto punto patrocinada por Dan Boneh , que es un nombre bien establecido y confiable en criptografía. y significa que el proyecto está supervisado por alguien que realmente sabe lo que está haciendo. El proyecto también cuenta con el apoyo de la NSF .

Sin embargo, vale la pena señalar ...
... que si aplica un hash a la contraseña del lado del cliente antes de enviarla, entonces el hash es la contraseña y la contraseña original se vuelve irrelevante. Un atacante solo necesita interceptar el hash para hacerse pasar por el usuario, y si ese hash se almacena sin modificar en el servidor, entonces el servidor almacena la contraseña verdadera (el hash) en texto sin formato .

Entonces, su seguridad ahora es peor porque decidió agregar sus propias mejoras a lo que antes era un esquema confiable.

En https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest encontré este fragmento que usa el 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;
}

Tenga crypto.subtleen cuenta que solo está disponible en httpso localhost, por ejemplo, para su desarrollo local python3 -m http.server, debe agregar esta línea a su /etc/hosts: 0.0.0.0 localhost

Reinicie y podrá abrir localhost:8000con el trabajo crypto.subtle.

La implementación de SHA-256 de Forge es rápida y confiable.

Para ejecutar pruebas en varias implementaciones de JavaScript SHA-256, vaya a http://brillout.github.io/test-javascript-hash-implementations/ .

Los resultados en mi máquina sugieren que Forge es la implementación más rápida y también considerablemente más rápida que la Stanford Javascript Crypto Library (sjcl) mencionada en la respuesta aceptada.

Forge tiene un tamaño de 256 KB, pero la extracción del código relacionado con SHA-256 reduce el tamaño a 4,5 KB, consulte https://github.com/brillout/forge-sha256

Para aquellos interesados, este es un código para crear 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)

No, no hay forma de utilizar JavaScript del navegador para mejorar la seguridad de las contraseñas. Le recomiendo que lea este artículo . En su caso, el mayor problema es el problema del huevo de gallina:

¿Cuál es el "problema del huevo de gallina" con la entrega de criptografía Javascript?

Si no confía en la red para entregar una contraseña o, peor aún, no confía en que el servidor no guarde secretos de usuario, no puede confiar en ellos para entregar el código de seguridad. El mismo atacante que estaba husmeando contraseñas o leyendo diarios antes de que introduzcas la criptografía simplemente está secuestrando el código criptográfico después de que tú lo hagas.

[...]

¿Por qué no puedo usar TLS / SSL para entregar el código criptográfico Javascript?

Usted puede. Es más difícil de lo que parece, pero transmite de forma segura criptografía Javascript a un navegador mediante SSL. El problema es que, después de haber establecido un canal seguro con SSL, ya no necesita la criptografía Javascript; tienes criptografía "real".

Lo que conduce a esto:

El problema con la ejecución de código criptográfico en Javascript es que prácticamente cualquier función de la que depende la criptografía podría ser anulada silenciosamente por cualquier parte del contenido utilizado para construir la página de alojamiento. La seguridad criptográfica se puede deshacer al principio del proceso (generando números aleatorios falsos o alterando las constantes y los parámetros utilizados por los algoritmos), o más tarde (enviando el material clave a un atacante), o --- en el escenario más probable --- pasando por alto la criptografía por completo.

No existe una forma confiable para que ningún fragmento de código Javascript verifique su entorno de ejecución. El código criptográfico de Javascript no puede preguntar: "¿Realmente estoy tratando con un generador de números aleatorios o con algún facsímil de uno proporcionado por un atacante?" Y ciertamente no puede afirmar que "nadie puede hacer nada con este secreto criptográfico, excepto en las formas que yo, el autor, apruebo". Estas son dos propiedades que a menudo se proporcionan en otros entornos que usan criptografía y son imposibles en Javascript.

Básicamente, el problema es este:

• Sus clientes no confían en sus servidores, por lo que quieren agregar un código de seguridad adicional.
• Ese código de seguridad lo entregan sus servidores (en los que no confían).

O alternativamente,

• Sus clientes no confían en SSL, por lo que quieren que use un código de seguridad adicional.
• Ese código de seguridad se envía a través de SSL.

Nota: Además, SHA-256 no es adecuado para esto, ya que es muy fácil forzar contraseñas no iteradas sin sal y sin forzar . Si decide hacer esto de todos modos, busque una implementación de bcrypt , scrypt o PBKDF2 .

Encontré esta implementación muy fácil de usar. También tiene una generosa licencia estilo BSD:

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

Necesitaba una forma rápida de obtener la representación de cadena hexadecimal de un hash SHA-256. Solo tomó 3 líneas:

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

Además de la biblioteca de Stanford que mencionó tylerl. Encontré jsrsasign muy útil (repositorio de Github aquí: https://github.com/kjur/jsrsasign ). No sé exactamente qué tan confiable es, pero he usado su API de SHA256, Base64, RSA, x509, etc. y funciona bastante bien. De hecho, también incluye la biblioteca de Stanford.

Si todo lo que quiere hacer es SHA256, jsrsasign podría ser una exageración. Pero si tiene otras necesidades en el área relacionada, creo que es una buena opción.