Kikoo,

Après de nombreuses recherches il semblerait que la fonction crypt soit la meilleure solution pour stocker les mots de passe. Right ?

Autrement je voudrais savoir comment l'utiliser car j'ai fait ceci mais ça ne marche pas

$mdp = crypt($_POST["mdp"]);
$MyQuery = "SELECT * FROM clients WHERE nom = '".$_POST["nom"]."' AND mdp = '".$mdp."'";

Les echos m'affichent des trucs différents

Merci de votre aide et bonne nuit ou journée

Salut,

As tu regarde, la doc de la fonction ? http://www.lephpfacile.com/cours/8-recu ... ormulaires
Les exemples sont assez explicite.

Celle ci recommandé aussi d'utiliser password_hash

Pour info on ne met pas le mot de passe dans le select.
On sélectionne le mdp crypté et comparé en php. (Question d'habitude et tu es certain d'avoir un retour cela permet de savoir si le compte utilisateur existe ou pas

@+

parce que, sans deuxième paramètre semence, chaque fois la fonction crypt crée une nouvelle semence aléatoire.
http://us2.php.net/manual/fr/function.crypt.php

voir aussi:
http://www.openwall.com/phpass/

Salut les garçons,

En fait je pensais que le sel généré par défaut permettait de retomber sur ses pattes mais je comprends mieux la problématique.

Un petit exemple :

$hashed_password = crypt('mypassword','poivre');
echo $hashed_password;

Du coup j'ai une petite série de questions :

1) Est-ce fort ou faible comme mdp ? Je ne suis pas experte, j'me rends pas bien compte...
2) Pourquoi et comment ne pas mettre le mdp dans le select ? Du coup tu fais comment moogli ?
3) password_hash n'est valable qu'à partir d'une version très récente de php. Si on a pas, on fait quoi, du sha1, md5 ou crypt ?

Merci à vous les loulous.

pour développer moogli:
Connexion : l'utilisateur fournit son identifiant et son mot de passe.($my_pass)
La requete ressemble à ça :
select identifiant, mot_de_passe from table where identifiant = mysql-real_escape($identifiant) ;
Si tu obtiens un résultat non vide ( 1 ou plusieurs lignes) si une des lignes contient $my_pass : connexion acceptée.

La force du mot de passe dépend de sa conception etnil faut uhne semence relativement longue, qu'il faut strocker quelque part.

iL EXISTE UNE AUTRE SOLUTION :

/**
 * creer_hachage($mot)
* \brief hache le mot de passe
* \version adaptée de la fonction de simans dot net sur fr2.php.net/manual
* \param $mot string le mot à crypter
* \return le mot crypté(60 cars)) et la semence (22 cars)) utilisée concaténée à la fin.
 */
function creer_hachage($mot )
{
	$force = "08";
	$semence = "";
	for ($i = 0; $i < 22; $i++)
	{
		$semence .= substr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", mt_rand(0, 61), 1);
	}
	return crypt($mot, "$2a$".$force."$".$semence).$semence;
}

ET

/*vERIFIER_HACHAGE*/
Function verifier_hachage($mot_clair, $mot_code)
 {
 	$force = "08";
 	if (substr ($mot_code, 0, 60) == crypt($mot_clair, "$2a$".$force."$".substr($mot_code, 60)))
 	{
 		return true;
 	}
 	else
 	{
 		return false;
 	}
}

Merci siramoogli

Tu veux dire que tu interroges le mot de passe qu'après ? Qu'au moment où tu "whilefetcharrayes" du verbe bien connu "whilefetcharrer"

+1 pour l'alternative sécurité

Oui, l'idée est de ne pas envoyer le mot de passe par internet à partir du formulaire :
ça limite les risques d'injection (d'où les mysql_real_escape)
On ne s'occupe du mot de passe que si l'identifiant existe.

Je pense que cette habitude tient surtout au cas où le passe est codé par mysql
UPDATE mysql.user SET Password=PASSWORD('newpass')
-> WHERE User='bob' AND Host='%.loc.gov';
car le mot de passe est envoyé en clair dans ce cas.

Une note toutes fois : la sécurité ne vaut que ce vaut le point le plus faible de la chaîne.

En clair si tu as un coffre fort avec des parois d'un mètre d'épaisseur et une combinaison a 18 caractères et que 3 combinaisons erronées a la suite, si tu laisse le code a côté de la porte ça sert a rien

Donc la dans le cas qui nous intéresse le bash du mot de passe c'est bien si l'on a accès a ta base parce que les n'y seront pas en clair.
Par contre danse contextes globale le maillon c'est généralement entre le client le serveur car les formulaires de connections sont rarement sur https et du coup tout circule en clair sur le réseau et donc récupérable

Sinon pour répondre a ta question oui un sha-xxx est utilisable (perso sha-512).
J'essai aussi d'utiliser un alto qui est utilisable sur le sgbd afin de pouvoir changer les mdp directement sur la base mais ceci est facultatif.

@+

Coucou,

Je reviens vers vous car je ne comprends pas bien la fonction "verifier_hachage" et surtout les paramètres passés.

Sur ma page courante j'ai créé le mot de passe suivant "monmotdepasse" //$2a$08$MxV8DBhMdgC4thdgIPRbOevi30Csn1dCxlI0gw0P4SBnGY/meHzQGMxV8DBhMdgC4thdgIPRbOq

Quelle valeur est stockée en bdd ?

Comment utiliser la fonction de vérification ?

echo verifier_hachage("monmotdepasse","c'est quoi le mot_code ?"); //Si je mets la valeur en commentaire le script couine

Merci à vous

à la création du compte:

//$passe_souhaite est en clair
$passe_code = creer_hachage ( $passe_souhaite );
		$requete = "INSERT into $table_u set `nom` = '$identifiant',`pass`='$passe_code', `email` ='$adresse_electronique', `niveau`='1' ";
		$resultat = $mysqli->query ( $requete );

à la vérification:

$passe = isset($_POST['passe']) ? $_POST['passe']:"";
$nom = isset($_POST['nom']) ? $_POST['nom']:"";

/**$entree boolean true si l'identifiant et le mot de passe sont exacts*/
$entree= false; //entree est un booléen exploité par le suite par défaut à false pour limiter les entrées non souhaiteées 
$mysqli = connexion($ServeurMysql, $RootMysql,$PassRootMysql);
$nom_table = $NomBdd.".kalig_utilisateurs";
$requete = "select * from $nom_table where `nom` = '$nom'";
$resultat = $mysqli->query($requete);
$ligne = $resultat->fetch_object();
if ($ligne == NULL)//_______________________________________________________________le nom n'existe pas
{
	exit(0);
}
//ici le nom existe
$passe_base = $ligne->pass; //mot de passe enreistré dans la BDD (codé par conséquent)
$entree = verifier_hachage ($passe, $passe_base)

;

Kikoo et merci !

C'est bien ce que j'ai fait puisque : $2a$08$MxV8DBhMdgC4thdgIPRbOevi30Csn1dCxlI0gw0P4SBnGY/meHzQGMxV8DBhMdgC4thdgIPRbOq = "monmotdepasse"

Seulement quand je mets
verifier_hachage("$passe_post","$passe_code");

qui revient à faire

verifier_hachage("monmotdepasse","$2a$08$MxV8DBhMdgC4thdgIPRbOevi30Csn1dCxlI0gw0P4SBnGY/meHzQGMxV8DBhMdgC4thdgIPRbOq")

Il interprète mon $ du $2a$08...comme une variable. Bizarre, enfin non, c'est quoi l'astuce ?

Fée

quand tu écris "$2a.." tu indiques une variable de ce nom; si tu mets un nom de variable, ça fonctionne; il suffit de regarder l'exemple...
Tout n'est pas équivalent de tout.
Si tu n'y parviens pas, tu devrais pouvoir remplacer dans les deux fonctions "$2a$" par une suite de 4 signes ne commençant pas par $

Bonsoir,

Je reviens vers vous car le script me plait bien mais je n'arrive pas à le faire fonctionner.

$passe_souhaite = "sirakawa";
$passe_code = creer_hachage ( $passe_souhaite );
echo $passe_code;

/* me renvoie $2a$08$uiVy44ggh4zD3FRRWf7lp.IU16oubWF3uZd.zQDtQBoh.FHgvrqW6
si je fais F5 $2a$08$ZSZHbVvxk426aXn5KisjTOzZgsK3sxZsTc/xhhD5adnv8XkpF42sG
...en somme jamais pareil */

mais je stocke une de ces valeurs dans mon varchar en base (que j'arrive à sortir en requêtant echo $rows...)

Quand j'appelle la fonction de vérification verifier_hachage($_POST["password"],$mavaleurenbase);

C'est toujours égal à KO :'(

svp

As tu tester le contenu de ta fonction pas a pas ?
Que retourne les substr ?
Que retourne la fonction crypt ?
Il faut que tu debogue cette fonction pour arriver a tes fins

@+

Ces fonctions fonctionnent parfaitement :
La fonction crypt crée une semence aléatoire à partir de laquelle elle crée un mot crypté de longueur fixe à la fin duquel se trouve la semance.
Le mot de passe crypté est stocké dans la BDD.
Lorsque l'utilisateur se connecte, il donne son identifiant et son mot de passe en clair. La BDD est consultée pour voir si l'identifiant existe et la fonction de vérification extrait la semence du mot de passe crypté provenant de la BDD et crypte avec cette semence le mot de passe en clair : les deux mots cryptés doivent être identiques.