Vader[FR] : ce n'est pas un blog, c'est un Sith

Fonctions pour PDO

Vader[FR] — 2018-07-01T10:29:46Z

PDO est une couche d'abstraction en PHP permettant d'adresser une base de données indépendamment de son type (MySQL, PostGres, Oracle...)
Par sécurité, il est préférable de faire des requêtes paramétrées afin d'éviter l'injection SQL.
Le contrecoup, c'est le rajout de code qui devient plus long à écrire.

Le code étant toujours le même, il est toutefois possible de le simplifier en créant une fonction simple qu'il suffira d'appeler.

Cette première fonction permet de préparer et exécuter une requête, laquelle peut être paramétrée, et dont le résultat pourra être :

plusieurs lignes, traitées ensuite dans une boucle foreach
un nombre de ligne modifié

Elle effectue donc un prepare, puis bindValue pour 0-n paramètres, puis un execute, et renvoie l'objet requête PDO.
les paramètres de la requêtes sont fournis dans un tableau qui commence à 1 (de préférence) ou zéro
la requête doit donc avoir " ?" en paramètre(s) afin de pouvoir les affecter depuis un tableau par indice, plus facilement traitable. voir l'exemple plus bas

function prepexec($rek,$params,$db){ if (isset($params[0])){ $debut=0; $correc=1; $fin=sizeof($params)-1; }else{ $debut=1; $correc=0; $fin=sizeof($params); } $rk=$db->prepare($rek); // si tableau param vide, pas de bindValue => fonction unique prepare avec/sans param + exec for ($i=$debut;$i<=$fin;$i++){ $typ_param=PDO::PARAM_STR;// PAR DEFAUT $param=$params[($i+$correc)]; if (preg_match("/[\w]+/",$param)){ $typ_param=PDO::PARAM_STR; } // PDO::PARAM_STR if (preg_match("/^[+-]?\d+$/",$param)){ $typ_param=PDO::PARAM_INT; } // PDO::PARAM_INT // PDO::PARAM_BOOL - MySQL might not support PARAM_BOOL if (preg_match("/^$/",$param)){ $typ_param=PDO::PARAM_NULL; } // PDO::PARAM_NULL $rk->bindValue($i,$param,$typ_param); } // renvoie la requête préparée et executée $rk->execute(); // $nb=$rk->execute(); OU foreach ($rk as $result){ // donc $nb=prepexec(... ou $rk=prepexec puis foreach($rk... ou même foreach(prepexec... return $rk; }

exemple d'appel :

 $rek="select count(login) as existe from utilisateur where login=?"; $params[1]=$user; $rk=prepexec($rek,$params,$db); $existe=0; foreach ($rk as $result){ $existe=$result['existe']; }

Cependant, cela est encore trop long.
Cette deuxième fonction va donc faire le boulot en appelant la première et en renvoyant la valeur attendue, unique, et dont le nom du champ est indiqué.

function simplexec($rek,$params,$db,$nomvar){ $resultat=null; $rk=prepexec($rek,$params,$db); foreach ($rk as $result){ $resultat=$result["$nomvar"]; } return $resultat; }

Fonctions sur les mots de passe

Vader[FR] — 2018-07-01T10:27:49Z

Diverses fonctions pour gérer l'authentification d'utilisateurs et le stockage sécurisé des mots de passe dans la BDD.

Vérification de la complexité d'un mot de passe

si la fonction renvoie une chaîne vide lorsqu'on l'appelle, tout baigne.

function chk_complex_mp($motpass){ $message=""; $patterns[0]="/^.*[A-Z].*+$/";	$complexe[0]="Il faut au moins une lettre majuscule
"; $patterns[1]="/^.*[a-z].*+$/";	$complexe[1]="Il faut au moins une lettre minuscule
"; $patterns[2]="/^.*[0-9].*+$/";	$complexe[2]="Il faut au moins un chiffre
"; $patterns[3]="/^.{8,}$/"; $complexe[3]="Il faut au moins 8 caractères
"; for ($i=0;$i

`Hashage de mot de passe avec sel, par algorithme choisi`


Cette fonction n'est qu'un exemple de fonction de cryptage, il est possible de faire plus souple/plus complexe.

A partir d'un mot de passe en clair, d'une chaîne de salage et d'un algorithme de hashage, elle :
 casse le sel en 3 parties de 10 caractères
 casse le mot de passe en 3 parties égales
 hash une première fois les morceaux de mot de passe mélangés aux morceaux de sel
 re-casse le mot de passe salé et hashé en 3 parties égales
 et enfin re-mélange le sel avec le mot de passe hashé.
function genere_motpasse($motpasse,$alt,$algo){ $alt1=substr($alt, 0, 10); $alt2=substr($alt, 10, 10); $alt3=substr($alt, 20, 10); $taillepass=strlen($motpasse); $taillemorceau=intval($taillepass/3); $pass1=substr($motpasse,0,$taillemorceau); $pass2=substr($motpasse,$taillemorceau,$taillemorceau); $pass3=substr($motpasse,($taillemorceau*2)); $passfin=hash($algo,"$pass1$alt1$pass2$alt2$pass3$alt3"); $taillepassf=strlen($passfin); $taillemorceauf=intval($taillepassf/3); $passf1=substr($passfin,0,$taillemorceauf); $passf2=substr($passfin,$taillemorceauf,$taillemorceauf); $passf3=substr($passfin,($taillemorceauf*2)); $passfou="$passf1$alt1$passf2$alt2$passf3$alt3"; // le mot de passe coupé, salé, hashé et re-salé est : return $passfou; }

`Génération de mot de passe aléatoire et/ou de sel`


voir l'article sur le salage en informatique sur Wikipedia.
Cette fonction génère donc une chaîne aléatoire, par exemple pour le sel aléatoire, qui devra être stocké, éventuellement pour chaque utilisateur.

Cela permet de se protéger (dans une certaine mesure) des attaques par rainbow table.
// génère une chaîne alpha-numérique aléatoire de longueur $taille function genere_chaine_aleatoire($taille) { $code_aleatoire=""; $chaine="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; srand((double)microtime()*1000000); for($i=0; $i<$taille; $i++) { $code_aleatoire.=$chaine[rand()%strlen($chaine)]; // ou $code_aleatoire .= substr($chaine,rand()%(strlen($chaine)),1); // ou $code_aleatoire .= $chaine[ rand(0, ($nb_chars-1)) ]; } // ou $code_aleatoire = str_shuffle('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'); return $code_aleatoire; }
si l'on veut casser et mélanger le sel et le mot de passe avant/après cryptage selon les chiffres compris dans le sel, il est possible, à sa génération, de rajouter une chaîne "0 à 9" au sel si celui-ci ne contient pas de chiffre, puis de mélanger le sel par la fonction str_shuffle().

`Choix d'un algorithme de hashage`


Ce bout de code cherche dans le tableau renvoyé par la fonction "hash_algos" les meilleurs algorithmes de hashage.

hash_algos() renvoie les algorithmes supportés sur le système.
Une fois trouvé, l'algorithme à utiliser pourra être stocké soit dans le fichier connect.php, soit dans la base de données, dans une table de méta-variables.

Les algorithmes à chercher sont triés par ordre "de préférence" du plus sûr (sha512, whrilpool...) au moins sûr (crc32).
 // chercher dans hash_algos si sha512, sha256, sha1... sont utilisables. $algos_prefs=array("sha512", "whirlpool", "sha384", "ripemd320", "sha256", "snefru256", "ripemd256", "snefru", "gost", "sha224", "ripemd160", "ripemd128", "fnv164", "joaat", "crc32b", "adler32", "fnv132", "crc32"); $algo=null; $i=0; $nbalgos=sizeof($algos_prefs); while (($i<$nbalgos)&&($algo==null)){ if (in_array($algos_prefs[$i],hash_algos())){ $info.="".$algos_prefs[$i]." est supporté
"; $algo=$algos_prefs[$i]; }else{ $info.="".$algos_prefs[$i]." non supporté
"; $i++; } } if ($algo==null){ $info.="Aucun algorithme supporté parmi ceux cherchés
"; $debug.="Aucun algorithme supporté parmi ceux cherchés"; }



Transformer une durée en secondes en sa description textuelle
Vader[FR] — 2018-07-01T10:23:43Z
// transforme une durée en secondes en sa description textuelle function sec2txt($durees){ $tabpuis=array("seconde","minute","heure","jour"); // + 30j/mois, 12 mois/an... ? $tabfrac=[60,60,24]; $traite=$durees; $puiss=0; $duree=""; while ($traite>=$tabfrac[$puiss]){ $reste=$traite%$tabfrac[$puiss]; $fraction=($traite-$reste)/$tabfrac[$puiss]; if ($reste>0){ $duree=($duree!="")?" $duree":$duree; $duree=($reste>1)?"$reste ".$tabpuis[$puiss]."s".$duree:"$reste ".$tabpuis[$puiss].$duree; } $puiss++; $traite=$fraction; } $duree=($duree!="")?" $duree":$duree; $duree=($traite>1)?"$traite ".$tabpuis[$puiss]."s".$duree:"$traite ".$tabpuis[$puiss].$duree; return $duree; }


Transformer un nombre (entier naturel) en sa description textuelle
Vader[FR] — 2018-07-01T10:20:45Z
// transforme un nombre en sa description textuelle
function num2txt($num){ $res=($num<0)?"moins":""; $tabchiffres=array("","un","deux","trois","quatre","cinq","six","sept","huit","neuf"); // commence à zéro ! $tabdix=array("","onze","douze","treize","quatorze","quinze","seize"); // idem $tabdizaines=array("","dix","vingt","trente","quarante","cinquante","soixante");	// idem $trnum=number_format($num); // pas de partie décimale, une , entre chaque millier $tabnum=explode(",",$trnum); $puiss=count($tabnum); // 1 = entre 0 et 999, 2 = entre 1000 et 999 999 milliers, 3 = entre 1 000 000 et 999 999 999 milions, 4 =... $tabpuis=array("","","mille","million","milliard"); // centaine/dizaine de milliards, centaine/dizaine de million, centaine/dizaine de millier, centaine/dizaine/unité foreach ($tabnum as $milnum){ $taillenum=strlen($milnum); $res.=($res!="")?" ":""; $verrounite=false; if ($taillenum==3) { // si 3 chiffres, traiter centaines // si 0 = rien, sinon x cent(s) if ($milnum[0]==1){ $res.="cent"; } if ($milnum[0]>1){ $res.=$tabchiffres[$milnum[0]]." cent"; $res.=(($milnum[1]>0)||($milnum[2]>0)||($puiss>=2))?"s":""; } } if ($taillenum>=2) { // si 2 chiffres, traiter dizaines $pos=($taillenum==3)?1:0; $res.=($res!="")?" ":""; //$res.=($pos!=0)?" ":""; $next=$pos+1; // si 1 if ($milnum[$pos]==1){ if (($milnum[$next]>=1)&&($milnum[$next]<=6)){ // onze à seize $res.=$tabdix[$milnum[$next]]; $verrounite=true; }else{ // 0 +	si 7 à 9 = dix- $res.=$tabdizaines[1]; $res.=($milnum[$next]>=7)?"-":""; } } // si 2 à 6 if (($milnum[$pos]>1)&&($milnum[$pos]<7)){ $res.=$tabdizaines[$milnum[$pos]]; $res.=($milnum[$next]>0)?"-":""; } // si 7, 8 et 9 qui utilisent aussi le chiffre des unités if ($milnum[$pos]==7){ $res.="soixante"; if ($milnum[$next]==0){ $res.="-dix"; } if ($milnum[$next]==1){ $res.=" et onze"; } if (($milnum[$next]>=2)&&($milnum[$next]<=6)){ $res.="-".$tabdix[$milnum[$next]]; } if ($milnum[$next]>=7){ $res.="-dix-".$tabchiffres[$milnum[$next]]; } $verrounite=true; } if ($milnum[$pos]==8){ //$verrounite=true; $res.="quatre-vingt"; if ($milnum[$next]>1){ $res.="-"; } } if ($milnum[$pos]==9){ $res.="quatre-vingt"; if ($milnum[$next]==0){ $res.="-dix"; } if (($milnum[$next]>=1)&&($milnum[$next]<=6)){ $res.="-".$tabdix[$milnum[$next]]; } if ($milnum[$next]>=7){ $res.="-dix-".$tabchiffres[$milnum[$next]]; } $verrounite=true; } } if ($taillenum>=1) { // si 1 chiffres $pos=$taillenum-1; // dernier chiffre 2-1 = 1 ? 3-1=2 if ($pos==0){ // 1 seul chiffre, donc si >1 ou 1 et puiss = 1, afficher le chiffre $res.=(($milnum>1)||(($milnum==1)&&($puiss==1)))?$tabchiffres[$milnum]:""; }else{ if ((!$verrounite)&&($milnum[$pos]!=0)){ // si chiffre dizaine != 7, 8 ou 9 $pre=$pos-1; if ($milnum[$pre]==0){ $res.=$tabchiffres[$milnum[$pos]]; } // si dizaine if ($milnum[$pre]==1){ // déjà un tiret $res.=$tabchiffres[$milnum[$pos]]; } // si vingt à 60 ou 80, et 1, mettre x et 1 if (((($milnum[$pre]>=2)&&($milnum[$pre]<=6))||($milnum[$pre]==8))&&($milnum[$pos]==1)){ $res.="et-".$tabchiffres[$milnum[$pos]]; } // si vingt à 60 ou 80 et pas 1 if (((($milnum[$pre]>=2)&&($milnum[$pre]<=6))||($milnum[$pre]==8))&&($milnum[$pos]!=1)){ $res.=$tabchiffres[$milnum[$pos]]; } } } } // si total>1, mettre le tabpuiss[puiss] if (($milnum>=1)&&($tabpuis[$puiss]!="")){ $res.=($res!="")?" ":""; $res.=$tabpuis[$puiss]; // mille est invariable // mais million, non $res.=(($puiss==3)&&($milnum>1))?"s":""; } $puiss--; } if ($num==0){ $res="zéro"; } return $res;
}