PBKDF2WithHmacSHA512 vs. PBKDF2WithHmacSHA1

Sto lavorando su un sottosistema di autenticazione Java che specifica la memorizzazione delle password nel DB come hash PBKDF2 da PBKDF2 e sto cercando ora di decidere se utilizzare SHA1 o SHA512 come PFR. Ho esaminato le specifiche di entrambi, ma sono molto matematicamente intensivi da seguire. Qualcuno con una migliore comprensione crypto può spiegare come PBKDF2WithHmacSHA512 differisca da PBKDF2WithHmacSHA1 ?

Ecco cosa sto cercando di fare:

 private static final int HASH_BYTE_SIZE = 64; // 512 bits private static final int PBKDF2_ITERATIONS = 1000; // generate random salt SecureRandom random = new SecureRandom(); byte salt[] = new byte[SALT_BYTE_SIZE]; // use salt size at least as long as hash random.nextBytes(salt); // generate Hash PBEKeySpec spec = new PBEKeySpec(password, salt, PBKDF2_ITERATIONS, HASH_BYTE_SIZE); SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1"); // we would like this to be "PBKDF2WithHmacSHA512" instead? What Provider implements it? byte[] hash = skf.generateSecret(spec).getEncoded(); // convert hash and salt to hex and store in DB as CHAR(64)... 

Cerchiamo di ripartire la parola pezzo per pezzo:

 PBKDF2--WithHmac--SHA512 

Andiamocene parte per parte

  • PBKDF2

    Stands for Key-Derivative-Function basato su password, un successore di PBKDF1 e viene utilizzato per implementare una funzione pseudocasuale, come un hash crittografico, cifrario o HMAC alla password o passphrase di input insieme a un valore salt e ripete il processo molte volte per produrre una chiave derivata, che può quindi essere utilizzata come chiave crittografica nelle operazioni successive.

  • HMAC

    Stands for Keyed-Hash Message Authentication Code (HMAC) è una costruzione specifica per il calcolo di un codice di autenticazione dei messaggi (MAC) che coinvolge una funzione di hash crittografica in combinazione con una chiave crittografica segreta. Qualsiasi funzione di hash crittografica, può essere utilizzata nel calcolo di un HMAC; l’algoritmo MAC risultante è definito HMAC-MD5 o HMAC-SHA1 di conseguenza.

  • SHA512

    Bene, tu lo sai ..: P

Ora, tornando alla tua domanda, la riga di codice:

 SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1"); 

specifica keyFactory per utilizzare l’algoritmo PDBKDF2WithHmacSHA1 . Quando dovresti fare qualcosa come:

 SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512"); 

dici alla fabbrica di usare l’algoritmo PBDKF2WithHmacSHA512 .

Essentialy la differenza principale tra PBKDF2WithHmacSHA1 e PBKDF2WithHmacSHA512 è che:

  1. PBKDF2WithHmacSHA1 produrrà una lunghezza hash di 160 bit .
  2. PBKDF2WithHmacSHA512 produrrà una lunghezza hash di 512 bit .

Quindi quest’ultimo è più sicuro. Ma ci sono argomenti da entrambe le parti su quale sia sufficiente per la crittografia. Nessun dibattito. Sto solo dicendo

Alcune informazioni aggiuntive sui due algoritmi:

  1. HMACSHA1

    HMACSHA1 è un tipo di algoritmo hash con chiave costruito con la funzione hash SHA1 e utilizzato come codice di autenticazione dei messaggi basato su hash o HMAC. Il processo HMAC miscela una chiave segreta con i dati del messaggio, esegue il hash del risultato con la funzione hash, mescola nuovamente il valore hash con la chiave segreta e quindi applica la funzione hash una seconda volta. L’hash dell’output è lungo 160 bit.

  2. HMACSHA512

    HMACSHA512 è un tipo di algoritmo hash con chiave creato con la funzione hash SHA-512 e utilizzato come HMAC (Message Authentication Code) basato su hash. Il processo HMAC mescola una chiave segreta con i dati del messaggio e blocca il risultato. Il valore di hash viene mescolato di nuovo con la chiave segreta e quindi cancellato una seconda volta. L’hash dell’output è lungo 512 bit.

Il vantaggio principale è che HmacWith512 è più sicuro di HmacWith256 . Per es

 HMAC_SHA1("key","The quick brown fox jumps over the lazy dog") = 0xde7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9 HMAC_SHA512("key","The quick brown fox jumps over the lazy dog") = 0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3a 

La differenza è abbastanza grande (come visto). Spero che sia d’aiuto. 🙂

EDIT: come cita OP

 PBEKeySpec(char[] password, byte[] salt, int iterationCount, int keyLength) 

Il parametro keyLength viene utilizzato per indicare la preferenza sulla lunghezza della chiave per le cifre a chiave variabile. Le dimensioni effettive della chiave dipendono dall’implementazione di ciascun fornitore. Quindi dire, fare qualcosa come

PBEKeySpec(password, salt, int 100, 512) non significa che si utilizzerà SHA1 per generare una lunghezza chiave di 512. Significa semplicemente che. SHA1 supporta fino a un massimo di 160 bit. Non puoi eccedere.

Per quanto riguarda la tua seconda domanda, dai un’occhiata a HMAC-SHA1 . Ci sono molte affermazioni che dicono che algoritmi come SHA256 sono piuttosto buoni se si ha un lungo hash.

Inoltre, come per la NSA:

L’NSA specifica che “La crittografia a chiave pubblica a curva ellittica che utilizza la curva ellittica a modulo primo a 256 bit come specificato in FIPS-186-2 e SHA-256 è appropriata per proteggere le informazioni classificate fino al livello SECRET. la curva ellittica modulo e SHA-384 sono necessari per la protezione delle informazioni TOP SECRET.

Penso che l’uso di una funzione HMAC in combinazione con SHA512 sia abbastanza sicuro.

SHA512 appartiene alla famiglia SHA2 di funzioni hash crittografiche. Poiché SHA1 ha debolezze teoriche e SHA512 è leggermente più lento di SHA1 (più lento è meglio quando si utilizzano le password di hashing), SHA512 (o qualsiasi altra famiglia SHA2) deve essere scelto su SHA1 ai fini delle password di hashing.

In realtà comprendere le differenze nelle funzioni non sarà semplice, ma potresti avere una migliore possibilità di ottenere una risposta sul sito Crypto SE .