En utilisant PBKDF2 avec la bibliothèque OpenSSL

J'ai un travail, mais pauvre C exemple de PBKDF2 via les bibliothèques OpenSSL à mon dépôt github, y compris les scripts de compilation sous Linux et Windows (via MinGW). Le code Source se trouve sous "Rejets", est bien connu; le code source dans la branche master est un WIP. Cette variante est autorisée dans les mêmes 4-clause BSD en plus de SSLeay licence OpenSSL est.

Je travaille toujours sur l'ajout de quelques fonctionnalités, puis je vais revenir à l'entrée excellent je l'ai eu sur la Révision du Code StackExchange site et de mise à niveau de C99 de la syntaxe et ainsi de suite.

Le code de base est très primitif, et peut contenir des erreurs malgré l'adoption d'une très vaste chaîne de vecteurs de test. Il n'a pas (encore) été testé contre le pur de l'entrée binaire.

#include <openssl/evp.h>
#include <openssl/sha.h>
//crypto.h used for the version
#include <openssl/crypto.h>

void PBKDF2_HMAC_SHA_1nat_string(const char* pass, const unsigned char* salt, int32_t iterations, uint32_t outputBytes, char* hexResult)
{
    unsigned int i;
    unsigned char digest[outputBytes];
    PKCS5_PBKDF2_HMAC_SHA1(pass, strlen(pass), salt, strlen(salt), iterations, outputBytes, digest);
    for (i = 0; i < sizeof(digest); i++)
        sprintf(hexResult + (i * 2), "%02x", 255 & digest[i]);
}

Si vous avez un système 64 bits, je vous recommande fortement de passer jusqu'à PBKDF2-HMAC-SHA-512 ou PBKDF2-HMAC-SHA-384 place:

#include <openssl/evp.h>
#include <openssl/sha.h>
//crypto.h used for the version
#include <openssl/crypto.h>


void PBKDF2_HMAC_SHA_384_string(const char* pass, const unsigned char* salt, int32_t iterations, uint32_t outputBytes, char* hexResult)
{
    unsigned int i;
    unsigned char digest[outputBytes];
    PKCS5_PBKDF2_HMAC(pass, strlen(pass), salt, strlen(salt), iterations, EVP_sha384(), outputBytes, digest);
    for (i = 0; i < sizeof(digest); i++)
        sprintf(hexResult + (i * 2), "%02x", 255 & digest[i]);
}

void PBKDF2_HMAC_SHA_512_string(const char* pass, const unsigned char* salt, int32_t iterations, uint32_t outputBytes, char* hexResult)
 {
     unsigned int i;
     unsigned char digest[outputBytes];
     PKCS5_PBKDF2_HMAC(pass, strlen(pass), salt, strlen(salt), iterations, EVP_sha512(), outputBytes, digest);
     for (i = 0; i < sizeof(digest); i++)
         sprintf(hexResult + (i * 2), "%02x", 255 & digest[i]);
 }    

Un exemple d'utilisation serait:

//2*outputBytes+1 is 2 hex bytes per binary byte, 
//and one character at the end for the string-terminating 
//2*outputBytes+1 is 2 hex bytes per binary byte, 
//and one character at the end for the string-terminating \0
char hexResult[2*outputBytes+1];
memset(hexResult,0,sizeof(hexResult));
PBKDF2_HMAC_SHA_1nat_string(pass, salt, iterations, outputBytes, hexResult);
printf("%s\n", hexResult);

char hexResult[2*outputBytes+1];
memset(hexResult,0,sizeof(hexResult));
PBKDF2_HMAC_SHA_1nat_string(pass, salt, iterations, outputBytes, hexResult);
printf("%s\n", hexResult);

ou

//2*outputBytes+1 is 2 hex bytes per binary byte, 
//and one character at the end for the string-terminating 
//2*outputBytes+1 is 2 hex bytes per binary byte, 
//and one character at the end for the string-terminating \0
char hexResult[2*outputBytes+1];
memset(hexResult,0,sizeof(hexResult));
PBKDF2_HMAC_SHA_512_string(pass, salt, iterations, outputBytes, hexResult);
printf("%s\n", hexResult);

char hexResult[2*outputBytes+1];
memset(hexResult,0,sizeof(hexResult));
PBKDF2_HMAC_SHA_512_string(pass, salt, iterations, outputBytes, hexResult);
printf("%s\n", hexResult);

Utiliser un hasard, par utilisateur, sel de 8 à 16 binaire octets, soit 16 à 32 chiffres hexadécimaux - mon code n'est PAS d'avoir des exemples de générer ce encore

Peu importe ce que vous choisissez, assurez-vous de vérifier contre les vecteurs de test (quelques-uns sont en pbkdf2_test.bat/sh dans mon référentiel).

En outre, sur votre système, faites un peu de benchmarking - certainement sur le PBKDF2-HMAC-SHA-384 et PBKDF2-HMAC-SHA-512 variantes, la compilation sous un système 64 bits produit radicalement de meilleurs résultats. Le comparer à mon tout aussi pauvres C++ Crypto++ et/ou mon pauvre C PolarSSL exemples, ou Jither C# exemple de mise en œuvre, selon ce que votre système cible.

La raison pour laquelle vous soucier de la vitesse, c'est que vous devez choisir un nombre d'itérations, basé sur la performance de votre système de production a disponibles par rapport au nombre d'utilisateurs qui se connectent/créer des mots de passe aux heures de pointe, de manière à ne pas générer trop de plaintes de la lenteur.

Attaquants vont utiliser quelque chose comme oclHashcat, qui, sur un seul PC avec 8x AMD R9 290Xstock horloge de base est en mesure de tenter 3.4E12 (2^41) devine tous les 30 jours contre PBKDF2-HMAC-SHA-1(SSID que le sel, le mot de passe de 32 octets de sortie longueur, 4096 itérations, une.k.un. WPA/WPA2), qui est plus ou moins équivalent à PBKDF2-HMAC-SHA-1(sel,pw,20 octets de sortie longueur, 8192 itérations).

• si vous utilisez 65536 itérations, l'attaquant sera seule en mesure d'essayer de 8.5E11 (~2^39) devine tous les 30 jours.
• si vous utilisez 1024 itérations, l'attaquant va plutôt essayer les 2.7E13 (~2^44) devine tous les 30 jours.

La différence devient important lorsque l'attaquant commence dans le choix de leurs attaques.

• Dans les deux cas, l'attaquant va à la force brute de très petites touches, il n'y a aucune raison de ne pas passer quelques minutes ou même quelques heures sur les fruits mûrs.
  • C'est tous les caractères hexadécimaux pour la longueur de la 1-n, et alors tous les caractères imprimables de longueur n+1 à n+m, puis aller en bas de la ligne jusqu'à n+y avec une codé en dur ! à la fin :).
• Dans les deux cas, le pirate va utiliser de minuscules dictionnaires et de petits jeux de règles, dites le phpbb dictionnaire de 184389 mots et les Best64 jeu de règles
  • Si vous aviez 1000 utilisateurs avec 1000 aléatoire différent sels et utilisé PBKDF2-HMAC-SHA-1 avec 65536 itérations, qui va prendre notre seul PC, 8 GPU attaquant (184389*64*1000)/(8.5E11/30) jours = 0.41 jours. Bien la peine!
• Maintenant, que penser de la même phpbb dictionnaire et les moyennes T0X1C jeu de règles de 4089 règles?
  • Si vous aviez 1000 utilisateurs avec 1000 aléatoire différent sels et utilisé PBKDF2-HMAC-SHA-1 avec 65536 itérations, qui va prendre notre seul PC, 8 GPU attaquant (184389*4089*1000)/(8.5E11/30) jours = 26.61 jours.
    • Encore la peine, mais c'est presque 4 semaines pour cette machine à dépenser sur une attaque!
  • Si vous aviez 1000 utilisateurs avec 1000 aléatoire différent sels et utilisé PBKDF2-HMAC-SHA-1 avec 65536 itérations, qui va prendre notre seul PC, 8 GPU attaquant (184389*4089*1000)/(2.7E13/30) jours = 0.83 jours.
    • En vaut la peine!
• Maintenant, que penser de la même phpbb et le dictionnaire de l'excellent d3ead0ne jeu de règles de 35404 règles?
  • Si vous aviez 1000 utilisateurs avec 1000 aléatoire différent sels et utilisé PBKDF2-HMAC-SHA-1 avec 65536 itérations, qui va prendre notre seul PC, 8 GPU attaquant (184389*35404*1000)/(8.5E11/30) jours = 230.39 jours.
    • Droit, l'heure d'acheter plus de machines ou de travailler sur ce dans des délais de.
  • Si vous aviez 1000 utilisateurs avec 1000 aléatoire différent sels et utilisé PBKDF2-HMAC-SHA-1 avec 65536 itérations, qui va prendre notre seul PC, 8 GPU attaquant (184389*4089*1000)/(2.7E13/30) jours = 7.18 jours.
    • En vaut la peine! C'est seulement une semaine et un repas.

Maintenant, pour PBKDF2, il ya quelques autres choses à savoir:

• Pour le hachage de mot de passe, ne jamais sélectionner une sortie binaire de taille plus grande que le natif de hachage de taille. Personnellement, je ne recommanderais pas une sortie binaire de taille de moins de 20 octets, peu importe, donc, c'est un peu limite pour SHA-1.
  • SHA-1 est de taille = 20 octets
  • SHA-224 est de 20 <= taille <= 28 octets
  • SHA-256 est de 20 <= taille <= 32 octets
  • SHA-384 20 <= taille <= 48 octets
  • SHA-512 est de 20 <= taille <= 64 octets
  • ajuster la façon dont vous stockez la valeur de hachage si ce n'est pas en binaire pur, bien sûr.
  • Raison: PBKDF2 exécutez d'abord le nombre d'itérations requis pour un natif de la taille de la sortie (le nombre sur la droite, ci-dessus). Si vous voulais plus que cela, il parcourt tout le nombre d'itérations une fois de plus. Si vous vouliez de moins que cela, il tronque.
  • L'attaquant ne va correspondre à la première de la taille d'origine si les premiers octets de match, oui, c'est le mot de passe, de sorte que vous êtes mieux de l'augmentation de votre nombre d'itérations.