PBKDF2WithHmacSHA512 Vs. PBKDF2WithHmacSHA1

Je suis en train de travailler sur un projet Java sous-système d'authentification que les spécifications de stockage de mots de passe dans la base de données comme PBKDF2généré par de la cendre, et je suis maintenant en train de décider si je dois utiliser la SHA1 ou SHA512 comme PFR. Je suis allé à travers les spécifications des deux, mais ils sont très mathématiquement intensif pour moi de suivre. Quelqu'un peut-il avec une meilleure crypto-compréhension expliquer comment PBKDF2WithHmacSHA512 diffère de PBKDF2WithHmacSHA1?

Voici ce que j'essaie de faire:

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)...

OriginalL'auteur DTs | 2013-10-13

39

Permettez-nous de répartition de la parole, morceau par morceau:
```
PBKDF2--WithHmac--SHA512
```
Nous allons passer en revue une partie de la partie
- PBKDF2
  
  Est synonyme de Mot de passe de Clé Dérivée de la Fonction, un successeur de PBKDF1 et est utilisé pour mettre en œuvre une fonction pseudo-aléatoire, comme un hachage cryptographique, chiffrement, ou HMAC à l'entrée de mot de passe ou le mot de passe avec un sel de valeur et répète l'opération plusieurs fois pour produire un dérivé de la clé, qui peut ensuite être utilisé comme une clé de chiffrement dans la suite des opérations.
- HMAC
  
  Est synonyme de Hachage à clé Code d'Authentification de Message (HMAC) est une construction spécifique pour le calcul d'un code d'authentification de message (MAC) comportant une fonction de hachage cryptographique, en combinaison avec un secret de la clé de chiffrement. Toute fonction de hachage cryptographique,peut être utilisé dans le calcul d'un HMAC; le MAC algorithme est appelé HMAC-MD5 ou HMAC-SHA1 en conséquence.
- SHA512
  
  Eh bien, vous savez à ce sujet.. 😛
Maintenant, pour en revenir à votre question, la ligne de code:
```
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
```
spécifie le keyFactory à utiliser l'algorithme PDBKDF2WithHmacSHA1. Quand vous faites quelque chose comme:
```
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
```
vous dites à l'usine pour l'utilisation de l'algorithme de PBDKF2WithHmacSHA512.

Essentiellement la principale différence entre PBKDF2WithHmacSHA1 et PBKDF2WithHmacSHA512 est que:
1. La PBKDF2WithHmacSHA1 sera produire un hachage de la longueur de 160 bits.
2. La PBKDF2WithHmacSHA512 sera produire un hachage de la longueur de 512 bits.
D'où le dernier est plus sûr. Mais il y a des arguments des deux côtés, comme pour ce qui est suffisant pour le chiffrement. Pas de débat. Juste pour dire.

Quelques informations supplémentaires sur les deux algorithmes:
1. HMACSHA1
  
  HMACSHA1 est un type de hachage à clé algorithme qui est construit à partir de la fonction de hashage SHA1 et utilisé comme un HMAC, ou à base de hachage message
  code d'authentification. Le HMAC processus de mélange une clé secrète avec l'
  message de données, hache le résultat avec la fonction de hachage, les mélanges qui
  la valeur de hachage de la clé secrète de nouveau, puis applique la table de hachage
  fonction un deuxième temps. La sortie de hachage est de 160 bits de longueur.
2. HMACSHA512
  
  HMACSHA512 est un type de hachage à clé algorithme qui est construit à partir de
  le SHA-512 fonction de hachage et utilisé comme une base de Hachage Message
  Code d'authentification (HMAC). Le HMAC processus de mélanges d'une clé secrète avec
  le message de données et les tables de hachage le résultat. La valeur de hachage est mélangé avec de l'
  la clé secrète de nouveau, puis hachées une deuxième fois. La sortie de hachage
  est de 512 bits de longueur.
Le principal avantage est que HmacWith512 est plus sécurisé que HmacWith256. Par exemple
```
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 différence est assez énorme (on l'a vu). Espérons que cela aide. 🙂

EDIT: Que l'OP mentionne
```
PBEKeySpec(char[] password, byte[] salt, int iterationCount, int keyLength)
```
Le paramètre keyLength est utilisé pour indiquer la préférence sur la longueur de la clé
pour la variable-clé de la taille d'algorithmes. La clé réelle de la taille dépend de chaque fournisseur la mise en œuvre. Donc, dire, faire quelque chose comme

PBEKeySpec(password, salt, int 100, 512) ne signifie pas que vous serez en utilisant SHA1 pour générer un keyLength de 512. Cela signifie simplement que. SHA1 prend en charge jusqu'à un maximum de 160 bits. Vous ne pouvez pas dépasser.

Quant à votre deuxième question, jetez un oeil à la HMAC-SHA1. Il existe de nombreuses déclarations que dire des algorithmes tels que SHA256 est assez bon si vous avez une longue hachage.

Aussi, que par la NSA :

De la NSA, précise que "la Courbe Elliptique de Cryptographie de Clé Publique à l'aide de
256 bits du premier module courbe elliptique, comme spécifié dans la norme FIPS-186-2
et SHA-256 sont appropriés pour la protection des informations classifiées jusqu'
pour le niveau SECRET. L'utilisation de 384 bits, le premier module de courbe elliptique
et SHA-384 sont nécessaires pour la protection de TOP SECRET
de l'information.

Je pense que l'utilisation d'une fonction HMAC en conjonction SHA512 est tout à fait sécurisé.

Vous mentionnez que la principale différence entre PDBKDF2WithHmacSHA1 et PDBKDF2WithHmacSHA512 est qu'ils produisent de hachage différent de longueur (160bits vs 512bits respectivement). Cependant, je ne pense pas que c'est correct parce que le keyLength argument en PBEKeySpec(char[] password, byte[] salt, int iterationCount, int keyLength) régit la longueur de la table de hachage produit. Si je lance cette spécification 512, 256, et 160, je reçois respectifs des hachages de différentes longueurs.
"il y a des arguments des deux côtés, comme pour ce qui est suffisant pour le chiffrement". Tous les liens serait apprécié, j'aimerais la lire. Je peux trouver des comparaisons entre SHA1 vs SHA512, mais aucun d'entre PDBKDF2WithHmacSHA1 et PBKDF2WithHmacSHA512. Btw, j'ai essayé de faire SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512"); à l'origine, mais il jette un NoSuchAlgorithmException. Pas inclus dans javax.crypto? J'aimerais l'utiliser mais je ne peux pas trouver un Fournisseur de l'offre, en dehors de IAIK (ils facturent quelques milliers de dollars pour leur entreprise criminelle commune, bibliothèque, oopss..). Quelqu'un au courant d'autres options?
Vous faites une implication que la plus grande longueur de produit de hachage est un indicateur de la "plus sécurisé" méthode de hachage. Sans fournir des commentaires concernant les effets de la longueur de hachage pour un type particulier d'attaque, de dire des choses comme ça, c'est assez spéculatives. Par exemple, si la valeur de hachage (par exemple un mot de passe) est connu pour être assez court, disons 8 caractères, il ne fait pas de réelle différence de la taille de la sortie d'une méthode de hachage est, aussi longtemps qu'il peut être calculé assez rapide, une attaque par force brute est encore possible.
Dans PDBKDF2, la clé de sortie est une concaténation de "blocs" qui est généré de façon indépendante et avec une longueur déterminée par le HMAC, qui est à son tour déterminé par le sous-jacent de hachage. Par conséquent, pour le craquage PBKDF2 généré par hachage de mots de passe, seul le premier bloc est nécessaire. par exemple, pour le hachage de mot de passe avec PBKDF2/HMAC/SHA1, un de 160 bits de sortie a le même niveau de sécurité qu'une résolution de 1024 bits de sortie.
Telle une grande sortie n'est pas requise. Argon2i qui est actuellement à l'état-of-the-art recommandé de hachage de mot de passe de la fonction de 256 bits de sortie et lorsqu'il est utilisé pour le hachage de mot de passe, il est souvent tronquée à 128 bits. Voir ici pour une discussion détaillée: crypto.stackexchange.com/questions/39249/...

OriginalL'auteur user2339071
0

SHA512 appartient à la SHA2 famille de fonctions de hachage cryptographiques. Depuis SHA1 théorique a des faiblesses et SHA512 est légèrement plus lent que SHA1 (plus lente est mieux quand hachage des mots de passe), SHA512 (ou tout du SHA2 de la famille) doit être choisi sur SHA1 pour le but de hachage des mots de passe.

Réellement comprendre les différences dans les fonctions ne va pas être simple, mais vous pourriez avoir une meilleure chance d'obtenir une réponse sur le Crypto SE site.

À droite, la vitesse (ou l'absence) est critique. Mais PBKDF2 comprend un accordable de travail du facteur. Par conséquent, la vitesse relative de SHA512 vs SHA1 n'est pas pertinent.

OriginalL'auteur Spencer Uresk

Vous devez vous connecter pour publier un commentaire.