Esistono implementazioni javascript SHA-256 generalmente considerate affidabili?

Sto scrivendo un login per un forum e ho bisogno di hash della password lato client in javascript prima di inviarla al server. Ho problemi a capire di quale implementazione SHA-256 posso effettivamente fidarmi. Mi aspettavo che ci fosse una sorta di script autorevole che tutti usassero, ma sto trovando un sacco di progetti diversi tutti con le proprie implementazioni.

Mi rendo conto che usare la crittografia di altre persone è sempre un atto di fede a meno che tu non sia qualificato per rivederla da solo, e che non esiste una definizione universale di "affidabile", ma questo sembra qualcosa di abbastanza comune e importante che dovrebbe esserci un qualche tipo di consenso su cosa usare. Sono solo ingenuo?

Modifica poiché emerge molto nei commenti: Sì, facciamo di nuovo un hash più rigoroso sul lato server. L'hashing lato client non è il risultato finale che salviamo nel database. L'hashing lato client è perché il client umano lo richiede. Non hanno dato una ragione specifica per cui, probabilmente a loro piace l'eccessivo.

Il Stanford JS Crypto Library contiene un'implementazione di SHA-256. Sebbene la crittografia in JS non sia davvero così ben controllata come altre piattaforme di implementazione, questa è almeno parzialmente sviluppata e in una certa misura sponsorizzata da Dan Boneh , che è un nome consolidato e affidabile nella crittografia e significa che il progetto ha una supervisione da parte di qualcuno che sa davvero cosa sta facendo. Il progetto è supportato anche dalla NSF .

Vale la pena sottolineare, tuttavia ...
... che se si esegue l'hash della password lato client prima di inviarla, l' hash è la password e la password originale diventa irrilevante. Un utente malintenzionato deve solo intercettare l'hash per impersonare l'utente e, se tale hash è archiviato non modificato sul server, il server memorizza la vera password (l'hash) in testo normale .

Quindi la tua sicurezza ora è peggiore perché hai deciso di aggiungere i tuoi miglioramenti a quello che in precedenza era uno schema affidabile.

Su https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest ho trovato questo frammento che utilizza il modulo 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;
}

Nota che è crypto.subtledisponibile solo suhttps o localhost- ad esempio per il tuo sviluppo locale con python3 -m http.serverdevi aggiungere questa riga al tuo /etc/hosts: 0.0.0.0 localhost

Riavvia e puoi aprirlo localhost:8000lavorando crypto.subtle.

FucinaL'implementazione SHA-256 di è veloce e affidabile.

Per eseguire test su diverse implementazioni JavaScript SHA-256, vai a http://brillout.github.io/test-javascript-hash-implementations/ .

I risultati sulla mia macchina suggeriscono che la forgiatura sia l'implementazione più veloce e anche notevolmente più veloce della Stanford Javascript Crypto Library (sjcl) menzionata nella risposta accettata.

Forge è grande 256 KB, ma l'estrazione del codice relativo a SHA-256 riduce le dimensioni a 4,5 KB, vedere https://github.com/brillout/forge-sha256

Per chi è interessato, questo è il codice per la creazione di hash SHA-256 utilizzando sjcl:

import sjcl from 'sjcl'

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

No, non è possibile utilizzare JavaScript del browser per migliorare la sicurezza delle password. Ti consiglio vivamente di leggere questo articolo . Nel tuo caso, il problema più grande è il problema dell'uovo di gallina:

Qual è il "problema dell'uovo di gallina" con la distribuzione della crittografia Javascript?

Se non ti fidi della rete per fornire una password o, peggio, non ti fidi del server per non mantenere i segreti degli utenti, non puoi fidarti di loro per fornire il codice di sicurezza. Lo stesso malintenzionato che stava sniffando password o leggendo diari prima di introdurre la crittografia sta semplicemente dirottando il codice crittografico dopo che lo hai fatto.

[...]

Perché non posso utilizzare TLS / SSL per fornire il codice crittografico Javascript?

Puoi. È più difficile di quanto sembri, ma trasmetti in modo sicuro la crittografia Javascript a un browser utilizzando SSL. Il problema è che, avendo stabilito un canale sicuro con SSL, non hai più bisogno della crittografia Javascript; hai una crittografia "reale".

Il che porta a questo:

Il problema con l'esecuzione di codice crittografico in Javascript è che praticamente qualsiasi funzione da cui dipende la crittografia potrebbe essere sovrascritta silenziosamente da qualsiasi contenuto utilizzato per costruire la pagina di hosting. La sicurezza crittografica potrebbe essere annullata nelle prime fasi del processo (generando numeri casuali fasulli o manomettendo le costanti e i parametri utilizzati dagli algoritmi), o successivamente (inviando materiale chiave a un utente malintenzionato), o --- nello scenario più probabile --- bypassando completamente la crittografia.

Non esiste un modo affidabile per qualsiasi pezzo di codice Javascript per verificare il proprio ambiente di esecuzione. Il codice crittografico Javascript non può chiedere: "Ho davvero a che fare con un generatore di numeri casuali o con qualche facsimile fornito da un aggressore?" E certamente non può affermare "a nessuno è permesso fare nulla con questo segreto crittografico se non in modi che io, l'autore, approvo". Queste sono due proprietà che spesso vengono fornite in altri ambienti che utilizzano la crittografia e sono impossibili in Javascript.

Fondamentalmente il problema è questo:

• I tuoi clienti non si fidano dei tuoi server, quindi vogliono aggiungere un codice di sicurezza extra.
• Quel codice di sicurezza viene fornito dai tuoi server (quelli di cui non si fidano).

O in alternativa,

• I tuoi clienti non si fidano di SSL, quindi vogliono che tu usi un codice di sicurezza aggiuntivo.
• Quel codice di sicurezza viene fornito tramite SSL.

Nota: Inoltre, SHA-256 non è adatto a questo, dal momento che è così facile forzare le password non salate e non iterate . Se decidi di farlo comunque, cerca un'implementazione di bcrypt , scrypt o PBKDF2 .

Ho trovato questa implementazione molto facile da usare. Ha anche una generosa licenza in stile BSD:

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

Avevo bisogno di un modo rapido per ottenere la rappresentazione in stringa esadecimale di un hash SHA-256. Ci sono volute solo 3 righe:

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

Oltre al lib di Stanford menzionato da Tylerl. Ho trovato jsrsasign molto utile (repository Github qui: https://github.com/kjur/jsrsasign ). Non so esattamente quanto sia affidabile, ma ho usato la sua API di SHA256, Base64, RSA, x509 ecc. E funziona abbastanza bene. In effetti, include anche la libreria Stanford.

Se tutto ciò che vuoi fare è SHA256, jsrsasign potrebbe essere eccessivo. Ma se hai altre esigenze nell'area correlata, penso che sia una buona soluzione.