Discussion :

[Masmeta]

Bonjour à tous.

J'ai un soucis sur la meilleur façon de faire pour l'utilisation d'un mot de passe dans une base de données. Ce mot de passe sert pour la connexion à un serveur smtp
Actuellement, j'ai une base de données qui comprend une table avec un champ password. La valeur est crypté suivant SHA1 de mysql (Update mytable set password=SHA1(mytext) where login='mylogin').

J'ai un programme en C++ qui lit ce champs. Comment je peut le decrypter ?
A-t-il une autre façon de faire ?

Je vous remercie de votre aide.
Cordialement

[jo_link_noir]

On ne décrypte pas un mot de passe, jamais ! Simplement parce qu'un mot de passe ne devrait pas être chiffré mais haché. Il n'y a donc pas de clef de chiffrement, mais seulement des méthodes de brute force pour trouver une collision (2 messages qui produise la même empreinte).

Pour comparer 2 mots de passe, il faut comparer les 2 valeurs hachées.

Sinon, Sha1 et dépassé ; oriente-toi vers sha3, au pire sha2 ou mieux encore des algorithmes de chiffrement symétrique comme Blowfish.

[Masmeta]

Oui je le comprend bien.
Alors comment puis je faire pour me connecter à mon serveur si je n'ai pas le mot de passe en clair ?

[BufferBob]

salut,

La valeur est crypté suivant SHA1 (...) Comment je peut le decrypter ?

SHA1 est une fonction de hachage, c'est à dire qui produit une empreinte (ou "hash") qui a justement les particularités de ne pas pouvoir être inversée et d'être unique pour un mot de passe donné
l'avantage c'est que si un pirate parvient à voler la base de données il ne peut justement pas récupérer les mots de passe en les déchiffrant simplement

donc le principe c'est que quand l'utilisateur rentre son mot de passe, le programme crée un hash SHA1 avec le mot de passe et compare le hash avec celui qui est dans la base, et si il correspond on est sûr que le mot de passe entré était le bon vu qu'il n'y a que le bon mot de passe qui peut donner le bon hash

Sinon, Sha1 et dépassé ; oriente-toi vers sha3, au pire sha2 ou mieux encore des algorithmes de chiffrement symétrique comme Blowfish.

c'est un vrai mauvais conseil ça, pourtant tu l'as fait remarquer juste avant, on ne chiffre pas un mot de passe en base on le hash, Blowfish est une fonction de chiffrement, il vaut encore mieux stocker les mots de passe en SHA1 qu'en Blowfish, si l'attaquant arrive à casser 1 mot de passe (et donc à trouver la clé de chiffrement, sur un mot de passe faible par exemple, dans l'intégralité d'une base de données ça doit pouvoir se trouver) tous les mots de passe sont compromis, tandis qu'exploiter les collisions sur SHA1 reste encore très complexe techniquement
mais d'accord avec le fait que SHA1 n'est plus considéré comme sûr pour autant, privilégier SHA512 autant que possible

[Masmeta]

Merci pour ses explications.
J'utilise SHA512 pour permettre la connexion de l'ihm web avec la base de données. Sur le principe, je suis tout a fait d'accord.
Mon souci est que j'ai une partie de configuration pour permettre de me connecter à un serveur smtp. J'ai donc le couple login - mot de passe.

Mon application est une application en ligne de commande pour une automatisation de tâche. Il n'y a aucun ihm.
Ce couple je le lis avec mon application c++ pour me permettre de me connecter au serveur smtp. Pour l'instant je ne voie que la solution de l'encrypt-decrypt.
Y a t il d'autre solution ?

[jo_link_noir]

@BufferBob: Effectivement, je me contredis à propos du chiffrement :/. Il me semble quand même que trouver la clef pour Blowfish passe par une méthode de brute force, donc potentiellement long et ne compromet pas l'ensemble de la bdd avec des salts aléatoires. D'ailleurs, blowfish fait partie des algos proposé par la fonction crypt.

Pour en revenir à la question initiale, ne faut-il pas utiliser des algos genre AES et déchiffrer avec le mot de passe utilisateur haché ? C'est plus une proposition qu'une réelle solution, je suis intéressé par la problématique.

[BufferBob]

Il me semble quand même que trouver la clef pour Blowfish passe par une méthode de brute force, donc potentiellement long et ne compromet pas l'ensemble de la bdd avec des salts aléatoires.

prenons un cas concret, si l'utilisateur a choisi mettons "love" comme mot de passe et que "love" est le premier mot de passe du dictionnaire de l'attaquant ça prendra quelques millièmes de secondes pour trouver la clé (le temps de chiffrer 1 mot de passe et le comparer), clé qui sera valide pour tous les autres mots de passe ensuite, et les salts ne serviront plus à rien

D'ailleurs, blowfish fait partie des algos proposé par la fonction crypt.

ok oui, en fait c'est l'algo bcrypt qui est utilisé, et est basé sur Blowfish, mais ça n'est pas tout à fait pareil et c'est une implémentation spécifique (idem pour les hash DES-based historiques)

Pour en revenir à la question initiale, ne faut-il pas utiliser des algos genre AES et déchiffrer avec le mot de passe utilisateur haché ?

hum.. je vois pas trop dans quel sens tu tournes ça, mais bon dans l'absolu si y'a vraiment pas d'autre moyen ben chiffrer en symétrique... et advienne que pourra, la feature primant souvent sur la sécurité

Mon souci est que j'ai une partie de configuration pour permettre de me connecter à un serveur smtp. J'ai donc le couple login - mot de passe.
(...)
Ce couple je le lis avec mon application c++ pour me permettre de me connecter au serveur smtp.

à vrai dire je comprends pas ce dont tu parles, une "partie de configuration pour permettre de se connecter"
au minimum j'ai du mal à comprendre l'enchainement des opérations, notamment la question du timing, pourquoi une application externe/en C++ a besoin d'aller après coup, lorsque l'utilisateur n'est plus connecté se connecter sur un smtp, manifestement externe lui aussi
quand l'utilisateur se connecte (ou s'enregistre) tu disposes à cet instant t de son login/mdp, tu ne pourrais pas en profiter pour effectuer toutes les tâches d'un coup par exemple ?

[white_tentacle]

Un AES peut très bien faire l’affaire pour chiffrer de manière réversible le mot de passe. Le problème est alors la sécurité de la clé. En effet, si la clé est compromise, l’ensemble des mots de passe sont compromis.

Une solution peut être d’utiliser une clé par utilisateur, et de protéger cette clé par une passphrase spécifique à l’utilisateur. Typiquement, si tu as déjà dans ton application un login / mdp spécifique à l’utilisateur, c’est éventuellement possible. Évidemment, si c’est une tâche de back-end, elle n’aura pas le mdp utilisateur et donc ce n’est pas possible de procéder ainsi.

Idéalement, la clé de chiffrement et les données chiffrées devraient résider sur des serveurs différents (pour compliquer la tâche d’un attaquant).

[Masmeta]

Bonjour
merci pour vos idées.

Je joins la solution que j'ai réalisé :
Code c++ avec libcrypto++-dev

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
#include <iostream>
#include <cryptopp/aes.h>
#include <cryptopp/modes.h>
#include <cryptopp/base64.h>
#include <mariadb/mysql.h>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <vector>
 
 
 
std::string encrypt(const std::string& str_in, const std::string& key, const std::string& iv)
{
    std::string str_out;
    CryptoPP::CFB_Mode<CryptoPP::AES>::Encryption encryption((byte*)key.c_str(), key.length(), (byte*)iv.c_str());
 
    CryptoPP::StringSource encryptor(str_in, true, 
        new CryptoPP::StreamTransformationFilter(encryption, 
            new CryptoPP::Base64Encoder(
                new CryptoPP::StringSink(str_out),
                false // do not append a newline
            )
        )
    );
    return str_out;
}
 
std::string decrypt(const std::string& str_in, const std::string& key, const std::string& iv)
{
    std::string str_out;
 
    CryptoPP::CFB_Mode<CryptoPP::AES>::Decryption decryption((byte*)key.c_str(), key.length(), (byte*)iv.c_str());
 
    CryptoPP::StringSource decryptor(str_in, true, 
        new CryptoPP::Base64Decoder(
            new CryptoPP::StreamTransformationFilter(decryption, 
                new CryptoPP::StringSink(str_out)
            )
        )
    );
    return str_out;
}
 
int main(int argc, char *argv[])
{
    std::string str = "Hello, world!";
    std::string key = "Q5412S7912FfgfhfgdgHTR45659917er"; // 32 bytes
    std::string iv  = "4sd1v5er5eR6417v";//16bytes
    std::string str_encrypted = encrypt(str, key, iv);
    std::string str_decrypted = decrypt(str_encrypted, key, iv);
    std::cout << "str_encrypted: " << str_encrypted << std::endl;
    std::cout << "str_decrypted: " << str_decrypted << std::endl;
 }

Et pour la partie PHP

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
<?php
	echo 'Test de cryptage <br/>';
	$string = 'Hello, world!';
    $key = 'Q5412S7912FfgfhfgdgHTR45659917er';
    $iv  = '4sd1v5er5eR6417v';    
 
    $method = 'aes-256-cfb';        
    $encrypted = base64_encode( openssl_encrypt ($string, $method, $key, true, $iv));
    $decrypted = openssl_decrypt( base64_decode($encrypted), $method, $key, true, $iv);
    echo "encrypted: $encrypted<br/>";
    echo "decrypted: $decrypted<br/>";

[Bousk]

Tous ces new sont plutôt choquants, ça leak pas ?

[Masmeta]

Tous ces new sont plutôt choquants, ça leak pas ?

C'est à dire ?
Je ne comprend pas ta question ?

[white_tentacle]

C'est à dire ?
Je ne comprend pas ta question ?

Tu alloues des objets avec new, mais vraisemblablement ne les libère jamais -> fuite mémoire (memory leak en anglais).

Tu n’es pas en java, tu dois comprendre comment gérer la durée de vie de tes objets (et donc, la mémoire associée).

[Masmeta]

J'avoue que j'ai suivi leur wiki. Je ne me suis pas posé la question des memory leak.

[white_tentacle]

Si c’est bien la façon canonique d’utiliser l’API (et ça en a l’air), c’est très vilain et daté. Un coup de valgrind (ou autre) te permettra de t’assurer qu’il n’y a pas de soucis.