lundi 1 avril 2013

Erreurs de requêtes MySQL en PHP

Erreurs de requêtes MySQL en PHP
La configuration du serveur doit être avec les Magic_quotes=Off pour que cette exemple fonctionne.

Le problèmes de mettre des variables dans une requête MySQL c'est la possibilité de pouvoir exploiter une faille par injection. Par contre, si votre serveur a les magic_quotes à On, vous ne risquez pas grand chose, enfin, moins. (à voir dans php.ini)

Un exemple de requête mysql pour une identification par login et mot de passe :

SELECT * FROM Table WHERE login='$login' AND password='$mdp'

Le formulaire pour être de ce genre :
Login :
<input name="mdp" id="mdp" type="text">
Mot de passe :
<input name="textfield2" type="text">


Le code qui récupèrera les données du formulaire :

<?php
$login = $_POST['login'];
$pass = $_POST['mdp'];
$req = "SELECT * FROM Table WHERE login='$login' AND password='$pass'";
?>


C'est un code que pas mal de débutants (plus haut aussi des fois :)) utilisent, bon, la suite ne marche pas sur tous les serveur, ça dépend de la configuration.
Aller maintenant sur la page du page formulaire et taper ceci :
Login : test1' or '1=1
Mot de passe : test2' or '1=1

Cliquer sur valider ...
et, surprise, vous est loguez !
Suffit ensuite de choisir mieux votre login pour tomber sur le compte de l'admin, ou root. ex :
Login : root' or '1=1
Mot de passe : test2' or '1=1


Explications
Voici à quoi ressemble votre requête avec les informations fourni par le formulaire :
$req="select * from Table where login='root' or '1=1' and password='test2' or '1=1'";

je pense que vous avez maintenant compris. En utilisant le OR '1=1, on est sur de toujours avoir une réponse affirmative.

Si vous ne pouvez changer la configuration de votre serveur, il suffit d'utiliser la function addslashes() pour ajouter des slash devant tous les ' ou "...
Le code sécurisé :
<?php
$login = mysql_real_escape_string($_POST['login']);
$pass = mysql_real_escape_string($_POST['mdp']);
$req = "SELECT * FROM Table WHERE login='$login' AND password='$pass'";
?>


Qui vous donnera cette requête :
$req = "SELECT * FROM Table WHERE login='root' OR '1=1' AND password='test2' OR '1=1'";

Si vous pouvez changer la configuration, editer le fichier php.ini, chercher la ligne magic_quotes=Off, et mettez On à la place de Off.

Si vous rencontrez des erreurs, des chose que je dit complètement fausses, merci de me prévenir.
Si vous utilisez EasyPhp 1.7, php.ini est déjà configurer avec les magic_quotes à On, donc, pas de soucis à ce faire !

Regexp les classes de regex

Les regex
Il peut également être utile de vérifier si une chaîne contient des caractères d'un certain type (numérique, alphanumérique, ...) sans avoir à les énumérer. Pour cela les expressions régulières définissent des classes de caractères, dont la syntaxe est:

[:classe:]

Les classes de caractères sont celles définies par UNIX. Voici un tableau récapitulant certaines de ces classes:

Nom de la classe Description
[:alnum:] caractères alphanumériques (équivalent à [A-Za-z0-9] )
[:alpha:] caractères alphabétiques ( [A-Za-z] )
[:blank:] caractères blanc (espace, tabulation)
[:ctrl:] caractères de contrôe (les premiers du code ASCII
[:digit:] chiffre ( [0-9] )
[:graph:] caractère d'imprimerie (qui fait une marque sur l'écran en quelque sorte)
[:print:] caractère imprimable (qui passe à l'imprimante ... tout sauf les caractères de contrôle)
[:punct:] caractère de ponctuation
[:space:] caractère d'espacement
[:upper:] caractère majuscule
[:xdigit:] caractère hexadécimal

Voici quelques exemples d'utilisation des classes de caractère dans une expression régulière :

chaine composée d'un ou plusieurs caractère(s) alphanumérique(s) "^[:alnum:]+$" chaine contenant un caractère de ponctuation ou un caractère d'espacement "[:punct:]|[:space:]" Un nombre "^[:digit:]+$"


Les fonctions de manipulation d'expressions régulières

PHP fournit quelques fonctions de bases permettant de manipuler des chaînes à l'aide d'expressions régulières.


Ce document issu de CommentCaMarche.net est soumis à la licence GNU FDL . Vous pouvez copier, modifier des copies de cette page tant que cette note apparaît clairement.

Les regex avec ereg eregi eregi_replace ereg_replace

ereg
La fonction ereg() dont la signature est la suivante :
Booleen ereg( chaine modèle,chaine texte[,tableau occurrences] )
permet d'évaluer le texte passer en argument grâce au modèle (qui est une expression régulière) et stocke toutes les occurrences dans un tableau passé optionnellement en paramètre. Lorsque la fonction trouve des occurrences, elle renvoie true , sinon elle retourne false .

eregi
La fonction eregi() dont la signature est la suivante :
Booleen eregi( chaine modele,chaine texte[,tableau occurrences] )
effectue le même travail que sa consœur ereg() , à la différence près qu'elle n'est pas sensible à la casse (pas de différenciation minuscules/majuscules)


<?

$fp = fopen("http://www.com%6dentcamarche%2enet","r"); //lecture du fichier
while (!feof($fp))
{ //on parcoure toutes les lignes
$page .= fgets($fp, 4096); // lecture du contenu de la ligne
}

$titre = eregi("<title>(.*)</title>",$page,$regs); //on isole le titre

/* Le titre commence par <title>, puis contient n'importe quelle chaine, et se termine par </title> */

echo $regs[1];
// on retourne la premiere occurence trouvée
// Les occurences se trouvent entre parenthèses
// $regs[0] renvoie toute la chaine

fclose($fp);

?>




Les fonctions ereg_replace et eregi_replace

La fonction ereg_replace() dont la signature est la suivante :
chaine ereg_replace( chaine modèle,chaine remplacement,chaine texte )
Permet de retourner la chaine texte passée en arguments avec les occurences trouvees remplacées par la chaine de remplacement.
Pour utiliser les occurrences correspondant au modèle dans la chaine de remplacement, il suffit d'utiliser des parenthèses dans la chaine modèle, puis de faire référence à ces éléments dans la chaine de remplacement en utilisant deux signes antislash suivi d'un numéro identifiant l'élément entre 0 et 9 (les numéros sont donnés par ordre imbriqués, puis de gauche à droite, le zéro représente la chaine entière).
Le code suivant remplace Toto par <b>Toti Toto</b>... inutile mais formateur.

$Texte = "Bienvenue a Toto dans le mondes des expressions régulières";
$Texte = ereg_replace("To(to)","<b>\1ti \0</b>",$Texte);

Le code suivant (utilisation avancée des expressions régulières) remplace un URL par un hypertexte HTML (il remplace toute suite de caractères de ponctuations et alphanum&eacuyte;riques commençant par http:// , ou ftp:// par le même texte (sans le http://) entre balises HTML hypertexte...):

$Texte = "Bienvenue sur http://www.commentcamarche.net cher ami";
$Texte = ereg_replace("(http://)(([[:punct:]]|[[:alnum:]])*)","<a href="\0">\2</a>",$Texte);

La fonction eregi_replace() dont la signature est la suivante :
chaine eregi_replace( chaine modèle,chaine remplacement,chaine texte )
effectue le même travail que sa consœur ereg_replace() , à la différence près qu'elle n'est pas sensible à la casse (pas de différenciation minuscules/majuscules).


La fonction split()

La fonction split() possède la syntaxe suivante:

tableau split (chaîne expression, chaîne texte [, entier limite])
La fonction split() retourne un tableau à partir d'une chaine et d'une expression régulière. La limite, optionnelle permet de limiter la taille du tableau retourné. Dans ce cas le dernier élément du tableau contient le reste de la chaine. Si une erreur se produit, split retourne 0.

<?

// découpe une phrase en un tableau de mots
// on utilise split au cas ou plusieurs espaces séparent les mots
$phrase = "Ceci est une phrase avec trois espaces ici";
$tableau_mots = split(" +",trim($phrase)); // un espace ou plus

?>



La fonction sql_regcase()

La fonction sql_regcase() possède la syntaxe suivante:

chaine sql_regcase (chaine texte)

Elle retourne une expression régulière qui représente la chaine passée en paramètre sans tenir compte de la case. Chaque caractère de la chaine est représenté entre crochets, avec deux caractères à l'intérieur un en majuscule et l'autre en minuscule, ou le cas échéant deux fois le même caractères. Aucune explication ne vaut un bon exemple ;)

<?

echo sql_regcase("un test"); // affiche [Uu][Nn][ ][Tt][Ee][Ss][Tt]

?>


Cette fonction permet de générer une chaine non sensible à la casse, pour les expressions régulières dans les bases de données par exemple. Dans MySQL lorsque vous utilisez la fonction REGEXP (au lieu de LIKE) la recherche est sensible à la casse. La solution est donc de générer une chaine non sensible à la casse à l'aide de sql_regcase.

<?

$motclef = sql_regcase("motclef");
$sql = "SELECT * from table WHERE champ REGEXP "[[:<:]]$motclef[[:>:]]"";
// selectionne tous les enregistrements de la table table, contenant le MOT motclef

?>



Ce document issu de CommentCaMarche.net est soumis à la licence GNU FDL . Vous pouvez copier, modifier des copies de cette page tant que cette note apparaît clairement.

Introduction aux expressions régulieres regex

Qu'est-ce qu'une expression régulière?

Les expressions régulières sont des modèles créés à l'aide de caractères ASCII permettant de manipuler des chaînes de caractères, c'est-à-dire permettant de trouver les portions de la chaîne correspondant au modèle. Ce système est emprunté au système POSIX (un système d'exploitation). De nombreux scripts sous UNIX les utilisent (notamment Perl ).

En réalité il s'agit d'un système fort ingénieux (et aussi très puissant) permettant de retrouver un mot, ou une phrase (et même beaucoup d'autres choses en réalité) dans un texte, ressemblant au modèle que l'on a construit...


Construire une expression régulière

Les expressions régulières permettent de rechercher des occurrences (c'est-à-dire une suite de caractères correspondant à ce que l'on recherche) grâce à une série de caractères spéciaux. L'expression régulière en elle-même est donc une chaîne de caractère contenant des caractères spéciaux et des caractères standards...

Les symboles ^ et $ indiquent le début ou la fin d'une chaine, et permettent donc de la délimiter. "^debut": chaine qui commence par "debut" "fin$": chaine qui se termine par "fin" "^chaine$": chaine qui commence et se termine par "chaine" "abc": chaine contenant la chaine "abc" Les symboles *, + et ?, respectivement "zero ou plusieurs", "un ou plusieurs", "un ou aucun", permettent de donner une notions de nombre. "abc+": chaine qui contient "ab" suivie de un ou plusieurs "c" ("abc", "abcc" etc..) "abc*": chaine qui contient "ab" suivie de zero ou plusieurs "c" ("ab", "abc" etc..) "abc?": chaine qui contient "ab" suivie de zero ou un "c" ("ab" ou "abc") "^abc+": chaine qui commence par "ab" suivie de un ou plusieurs "c" ("abc", "abcc" etc..)

Les accolades {X,Y} permettent de donner des limites de nombre. "abc{2}": chaine qui contient "ab" suivie de deux "c" ("abcc") "abc{2,}": chaine qui contient "ab" suivie de deux "c" ou plus ("abcc" etc..) "abc{2,4}": chaine qui contient "ab" suivie 2, 3 ou 4 "c" ("abcc" .. "abcccc") A noter que le premier nombre de la limite ("{0,2}", mais pas "{,2}") est obligatoire. Les symboles vu précedemment ('*', '+', and '?') sont équivalents à "{0,}", "{1,}", et "{0,1}".

Les parenthèses ( ) permettent de représenter une séquence de caractères. "a(bc)*": chaine qui contient "a" suivie de zero "bc" ou plus La barre verticale | se comporte en tant qu'opérateur OU "un|le": chaine qui contient "un" ou "le" "(un|le) chien": chaine qui contient "un chien" ou "le chien" "(a|b)*": chaine qui contient une suite de "a" ou de "b" Le point . indique n'importe quel caractère (une fois) "^.{3}$": chaine qui contient 3 caractères Les crochets [ ] définissent une liste de caractères autorisés (ou interdits). Le signe - permet quand à lui de définir un intervalle. Le caractère ^ après le premier crochet indique quand à lui une interdiction. "[abc]": chaine qui contient un "a", un "b", ou un "c" "[a-z]": chaine qui contient un caractère compris entre "a" et "z" "[^a-zA-Z]": chaine qui ne commence pas par une lettre



* Pour rechercher un caractère faisant partie des caractères spéciaux, il suffit de le faire précéder d'un antislash ( sauf entre crochets )
* un antislash doit donc être doublé!


En effet dans les crochets, chaque caractère représente ce qu'il est. Pour représenter un ] il faut le mettre en premier (ou après un ^ si c'est une interdiction), un - se met en premier ou en dernier. "[+?{}.]": chaine qui contient un de ces six caractères "[]-]": chaine qui contient le caractère "]" ou le caractère "-"

Voici un tableau récapitulatif des caractères spéciaux utilisés dans les expressions régulières:

Caractère Utilité
[] Les crochets définissent une liste de caractères autorisés
() Les parenthèse définissent un élément composé de l'expression régulière qu'elle contient
{} Les accolades lorsqu'elles contiennent un ou plusieurs chiffres séaprés par des virgules représente le nombre de fois que l'élément précédant les accolades peut se reproduire (par exemple p{2,5} correspond à ppp , pppp ou ppppp
- Un moins entre deux caractères dans une liste représente un intervalle (par exemple [a-d] représente [abcd] )
. Le caractère point représente un caractère unique
* Le caractère astérisque indique la répétition indéterminée de l'élément la précédant
? Le caractère "point d'interrogation indique la présence éventuelle de l'élément la précédant
| Occurence de l'élément situé à gauche de cet opérateur ou de celui situé à droite ( lard|cochon )
^

* Placé en début d'expression il signifie "chaîne commençant par .. "
* Utilisé à l'intérieur d'une liste il signifie "ne contenant pas les caractères suivants...

$ Placé en fin d'expression il signifie "chaîne finissant par .. "


Ce document issu de CommentCaMarche.net est soumis à la licence GNU FDL . Vous pouvez copier, modifier des copies de cette page tant que cette note apparaît clairement

Utiliser gzopen et gzread

gzopen -- Ouvre un fichier compressé
int gzopen(string filename, string mode);

Ouvre un fichier compressé avec gzip (.gz) pour le lire ou líécrire. Le paramètre de mode est le même que dans fopen() ("rb"
ou "wb") mais il peut aussi inclure un niveau de compression ("wb9") ou une stratégie: 'f' pour les données filtrées, comme
dans "wb6f", 'h' pour Huffman seul , comme dans "wb1h".

Gzopen peut être utilisé pour ouvrir des fichiers qui ne sont pas au format gzip; dans ce cas, gzread() lira directement le
fichier, sans appliquer de décompression.
Gzopen retourne un pointeur de fichier sur le fichier ouvert. Ce pointeur sera nécessaire pour toutes les opérations ultérieures
sur ce fichier. Les opérations de compression/décompression seront transparentes.
Si l'ouverture échoue, la fonction retourne faux (false).

Exemple :

<?php
$fp = gzopen("/tmp/file.gz", "r");
?>



gzread
gzread -- Lit un fichier compressé en mode binaire
string gzread(int zp, int length);

gzread() lis jusqu’à length octets depuis le fichier compressé référencé par zp. La lecture stoppe lorsque length octets
décompressés ont été lus, ou que la fin du fichier a été trouvée.

Exemple :
<?php
$filename = "/usr/local/something.txt.gz";
$zd = gzopen( $filename, "r" );
$contents = gzread( $zd, 10000 );
gzclose( $zd );
?>

Utilisation de continue et break

Voici un exemple pour comprendre l'utilité des fonctions continue et break


<html>
    <head><title>Continue, Break</title></head>
<body>
<p>
<?php
for ($i=0;$i<10;$i++)
{
    echo $i;  // va afficher 0,2,4,6,8
    $i++;
    echo $i;  // va afficher 1.3.5.7.9
}

echo "<br>";

for ($i=0;$i<10;$i++)
{
    echo $i;
    $i++;
   
    if ($i>4) break;
        echo $i;
}

echo "<br>";

for ($i=0;$i<10;$i++)
{
    echo $i;
    $i++;
   
    if ($i>4) continue;
        echo $i;
}
?>
</p>
</body>
</html>


Donne le résultat:

0123456789
01234
0123468

Upload PHP

L'upload en PHP est utilisé au travers du web en générale d'une façon très peux sécurisé (la plupart du temps, pas du tout sécurisé).
L'un des problèmes est le manque de mises en garde et d'exemples sécurisé d'upload PHP.
L'upload PHP n'est pas à prendre à la légère; On doit vraiment prendre en compte les risques de sécurités qu'il engendre.

Pour commencer, voici un exemple d'upload PHP très simple qui ne fais aucune vérification de sécurité.
Ne pas utiliser sur un site en production !


<form method="post" enctype="multipart/form-data" action="">
<input type="file" name="fichier" size="30">
<input type="submit" name="upload" value="Uploader">
</form>
<?php
// 1
if( isset($_POST['upload']) )
{
    $content_dir = $_SERVER['DOCUMENT_ROOT'].'/upload_dir/';

    // 2
    if( !is_uploaded_file($_FILES['fichier']['tmp_name']) )
    {
        exit("Le fichier est introuvable");
    }

    // 3
    if( !move_uploaded_file($_FILES['fichier']['tmp_name'], $content_dir . $_FILES['fichier']['name']) )
    {
        exit("Impossible de copier le fichier dans $content_dir");
    }

    echo "Le fichier a bien été uploadé";
}
?>


Explications :
1) On vérifie que le formulaire a bien été validé
2) Upload du fichier
3) déplacement du ficher de sen répertoire temporaire vers le répertoire d'upload de destination



Voyons maintenant un exemple d'upload PHP sécurisé (du moins, beaucoup plus sécurisé)

On vérifie quoi en faite ?
Ceci dépend de vous et de ce que vous voulez en faire, qui va avoir accès aux fichier, etc... Mais en règle générale :

- Extension
- Poids
- Caractères spéciales

Le code PHP d'upload sécurisé :
<form method="post" enctype="multipart/form-data" action="">
    <input type="file" name="fichier" size="30">
    <input type="submit" name="upload" value="Uploader">
</form>
<?php
if($_POST['upload'])
{
    // repertoire où vont être placé les fichiers
    $content_dir = $_SERVER['DOCUMENT_ROOT'].'/upload_dir/';
   
    // ajouter ici les autres extensions autorisé
    $extensions_OK = array('jpg', 'jpeg', 'gif', 'png', 'pdf', 'doc', 'docx', 'etc...');

    // Le nom du fichier ne peux pas être vide
    if(empty($_FILES['fichier']['name'])){
        exit("Aucun fichier sélectionné.");
    }

    // on test si le fichier est uploadé
    if( !is_uploaded_file($_FILES['fichier']['tmp_name']) ){
        exit("Le fichier n'a pas pu être uploadé.");
    }
   
    // récupération de l'extension du fichier
    $ext = strtolower( pathinfo($_FILES['fichier']['name'],  PATHINFO_EXTENSION) );
   
    // est ce que l'extension est valide ?
    if(!in_array($ext, $extensions_OK)) {
        exit("Le format de votre fichier n'est pas autorisé.");
    }

    // renommons le fichier pour plus de sécurité
    // ceci donne un nom de fichier très dur à trouver
    $name_file = md5( uniqid('H', 5) ).'.'.$ext;

    // upload
    if(!move_uploaded_file($tmp_file,$content_dir.$name_file)){
        exit("Impossible de copier le fichier !");
    }else{
        echo "Le fichier a bien été uploadé";
    }

}
?>


Dans cette exemple, on vérifie que le nom du fichier n'est pas vide, que l'extension est bien valide.
Puis, on le renomme pour avoir un nom de fichier très dur à trouver.


Et maintenant, une fonction PHP d'upload avec une utilisation très simple !
<?php
function upload($_files, $destination_rep)
{
    if(!empty($_files['fichier']['tmp_name']) && !empty($_files['fichier']['name']))
    {
        $tmp_file = $_files['fichier']['tmp_name'];

        //on test si l'upload a reussi
        if(!is_uploaded_file($tmp_file))
            exit('Erreur lors de l\'upload.');

        // on va ajouter une chaine pour rendre le nom du fichier unique et pratiquement introuvable.
        $unikifier = md5( uniqid('H', 5) );
       
        // extension du fichier
        $ext = pathinfo($_FILES['fichier']['name'],  PATHINFO_EXTENSION);

        // nettoyage du nom du fichier (on peux pas d'accents ou d'espace)
        $file_name = $unikifier.'.'.$ext;

        //on déplace le fichier vers notre répertoire de destination
        if(!move_uploaded_file($tmp_file, $destination_rep.$file_name))
            exit("Impossible de déplacer le fichier. Upload annulé.");
        else
            return $file_name;
    }
}


$file_dir = './upload_dir/';

if($_POST || $_FILES)
{
    $file = upload($_FILES, $file_dir);
    echo 'Upload terminé : '.$file;
}
else
{
    echo '
    <form method="post" enctype="multipart/form-data" action="">
        <input type="file" name="fichier" size="30">
        <input type="submit" name="upload" value="Uploader">
    </form>'
;
}
?>



On pourrait allez plus loin ? OUI !
Il faudrait définir le répertoire d'upload dans un endroit NON accessible depuis un navigateur web,
renommer complètement le fichier, vérifié que le fichier ne contient pas (DANS le fichier) du code PHP ou autre, vérifié le type MIME et faire une contre vérification avec l'extension.


Bon upload php !