Les RegExp dans preg_match fonction de retour d'erreur de navigateur

Simple question. Réponse complexe!

Oui, cette classe de regex va augmenter de façon répétée (et en silence) crash Apache/PHP avec un non gérée erreur de segmentation en raison d'un débordement de pile!

De fond:

Le PHP preg_* famille de fonctions regex utiliser le puissant Librairie PCRE par Philip Hazel. Avec cette bibliothèque, il y a une certaine catégorie de regex qui requiert un grand nombre d'appels récursifs à son match() fonction et cela utilise beaucoup d'espace de pile, (et de l'espace de pile utilisé est directement proportionnelle à la taille de la chaîne en cours d'appariement). Ainsi, si la chaîne est trop longue, un débordement de pile et correspondant à l'erreur de segmentation se produit. Ce comportement est décrit dans le PCRE de la documentation à la fin dans la section intitulée: pcrestack.

PHP Bug 1: PHP définit: pcre.recursion_limit trop grand.

Le PCRE de la documentation explique comment éviter un débordement de la pile faute de segmentation en limitant la profondeur de récursivité à une valeur sûre à peu près égale à la taille de la pile de l'application liée divisé par 500. Lorsque la profondeur de récursivité est bien limitée, comme recommandé, la bibliothèque n'est pas de générer un débordement de la pile et la place gracieusement quitte avec un code d'erreur. En vertu de PHP, ce maximum profondeur de récursion est spécifié avec le pcre.recursion_limit variable de configuration et (malheureusement) la valeur par défaut est fixé à 100 000. Cette valeur est TROP GRANDE! Voici un tableau des valeurs sûres de pcre.recursion_limit pour une variété de pile exécutable tailles:

Stacksize   pcre.recursion_limit
 64 MB      134217
 32 MB      67108
 16 MB      33554
  8 MB      16777
  4 MB      8388
  2 MB      4194
  1 MB      2097
512 KB      1048
256 KB      524

Ainsi, pour la version Win32 de du serveur web Apache (httpd.exe), qui a une (petite) taille de la pile de 256 KO, la valeur correcte de pcre.recursion_limit doit être réglé à 524. Ceci peut être accompli avec la ligne suivante de code PHP:

ini_set("pcre.recursion_limit", "524"); //PHP default is 100,000.

Lorsque ce code est ajouté au script PHP, le débordement de la pile ne se produit PAS, mais au lieu de cela génère un code d'erreur explicatif. C'est, il DEVRAIT générer un code d'erreur! (Mais malheureusement, à cause d'un autre bogue de PHP, preg_match() ne le fait pas.)

PHP Bug 2: preg_match() ne retourne pas FALSE en cas d'erreur.

La documentation PHP pour preg_match() dit qu'elle retourne FALSE en cas d'erreur. Malheureusement, les versions de PHP 5.3.3 ci-dessous et avoir un bug (#52732) où preg_match() ne retourne PAS FALSE sur l'erreur (au lieu renvoie int(0), qui est la même valeur renvoyée dans le cas d'un non-match). Ce bug a été corrigé dans la version de PHP 5.3.4.

Solution:

En supposant que vous continuerez à l'aide de WAMP 2.0 (avec PHP 5.3.0) la solution doit prendre les deux bugs en considération. Voici ce que je recommande:

• Nécessité de réduire pcre.recursion_limit à une valeur sûre: 524.
• Besoin explicitement vérifier pour un PCRE d'erreur à chaque fois que preg_match() renvoie autre chose que int(1).
• Si preg_match() retourne int(1), le match a été un succès.
• Si preg_match() retourne int(0), le match n'était pas réussi, ou il y avait une erreur.

Ici est une version modifiée de votre script (conçu pour être exécuté depuis la ligne de commande) qui détermine le sujet de la longueur de la chaîne qui aboutit à la limite de la récursivité d'erreur:

<?php
//This test script is designed to be run from the command line.
//It measures the subject string length that results in a
//PREG_RECURSION_LIMIT_ERROR error in the preg_match() function.
echo("Entering TEST.PHP...\n");
//Set and display pcre.recursion_limit. (set to stacksize /500).
//Under Win32 httpd.exe has a stack = 256KB and 8MB for php.exe.
//ini_set("pcre.recursion_limit", "524");       //Stacksize = 256KB.
ini_set("pcre.recursion_limit", "16777");   //Stacksize = 8MB.
echo(sprintf("PCRE pcre.recursion_limit is set to %s\n",
ini_get("pcre.recursion_limit")));
function parseAPIResults($results){
$pattern = "/\[(.|\n)+\]/";
$resultsArray = preg_match($pattern, $results, $matches);
if ($resultsArray === 1) {
$msg = 'Successful match.';
} else {
//Either an unsuccessful match, or a PCRE error occurred.
$pcre_err = preg_last_error();  //PHP 5.2 and above.
if ($pcre_err === PREG_NO_ERROR) {
$msg = 'Successful non-match.';
} else {
//preg_match error!
switch ($pcre_err) {
case PREG_INTERNAL_ERROR:
$msg = 'PREG_INTERNAL_ERROR';
break;
case PREG_BACKTRACK_LIMIT_ERROR:
$msg = 'PREG_BACKTRACK_LIMIT_ERROR';
break;
case PREG_RECURSION_LIMIT_ERROR:
$msg = 'PREG_RECURSION_LIMIT_ERROR';
break;
case PREG_BAD_UTF8_ERROR:
$msg = 'PREG_BAD_UTF8_ERROR';
break;
case PREG_BAD_UTF8_OFFSET_ERROR:
$msg = 'PREG_BAD_UTF8_OFFSET_ERROR';
break;
default:
$msg = 'Unrecognized PREG error';
break;
}
}
}
return($msg);
}
//Build a matching test string of increasing size.
function buildTestString() {
static $content = "";
$content .= "A";
return '['. $content .']';
}
//Find subject string length that results in error.
for (;;) { //Infinite loop. Break out.
$str = buildTestString();
$msg = parseAPIResults($str);
printf("Length =%10d\r", strlen($str));
if ($msg !== 'Successful match.') break;
}
echo(sprintf("\nPCRE_ERROR = \"%s\" at subject string length = %d\n",
$msg, strlen($str)));
echo("Exiting TEST.PHP...");
?>

Lorsque vous exécutez ce script, il permet une lecture de la longueur actuelle de la chaîne. Si le pcre.recursion_limit est laissé à sa trop élevée valeur par défaut, cela vous permet de mesurer la longueur de la chaîne qui provoque l'exécutable à l'écrasement.

Commentaires:

• Avant d'étudier la réponse à cette question, je ne savais pas à propos de PHP d'un bug où les preg_match() ne parvient pas à retourner FALSE lorsqu'une erreur se produit dans la librairie PCRE. Ce bug certainement remet en question BEAUCOUP de code qui utilise preg_match! (Je vais certainement aller faire un inventaire de ma propre code PHP.)
• Sous Windows, le serveur web Apache exécutable (httpd.exe) est construit avec un stacksize de 256 KO. Le PHP en ligne de commande exécutable (php.exe) est construit avec un stacksize de 8 mo. La valeur sûre pour les pcre.recursion_limit doivent être mis en conformité avec le fichier exécutable que le script est en cours d'exécution en vertu de l' (524 et 16777 respectivement).
• Sous les systèmes *nix, le serveur web Apache et de la ligne de commande exécutables sont à la fois typiquement construits avec un stacksize de 8 MO, donc ce problème n'est pas rencontré souvent.
• Les développeurs PHP doit définir la valeur par défaut de pcre.recursion_limit une valeur sûre.
• Les développeurs PHP doit s'appliquer à la preg_match() correction de la version de PHP 5.2.
• La taille de la pile d'un exécutable Windows peuvent être modifiés manuellement, à l'aide de la CFF Explorer programme freeware. Vous pouvez utiliser ce programme pour augmenter la taille de la pile de l'Apache httpd.exe exécutable. (Cela ne fonctionne que sous XP mais Vista et Win7 pourraient se plaindre.)

J'ai eu le même problème et que vous avez besoin pour change le modèle de quelque chose comme

$pattern = '|/your pattern/|s';

Le " s " à la fin signifie traiter la chaîne de caractères sur une seule ligne.