Le 1er avril 2020, l’équipe Wordfence Threat Intelligence a découvert deux vulnérabilités dans MapPress Maps pour WordPress, un plugin WordPress avec plus de 80 000 installations. Une vulnérabilité qui permettait le cross-site scripting (XSS) stocké était présente dans les versions gratuite et pro du plugin, tandis qu’une vulnérabilité beaucoup plus critique qui permettait l’exécution de code à distance (RCE) était présente dans la version pro.

Nous avons contacté l’auteur du plugin le lendemain, 2 avril 2020, et avons reçu une réponse en quelques heures. Une version corrigée de MapPress Free et MapPress Pro a été publiée en quelques heures. Nous vous recommandons fortement de mettre à jour les versions gratuite et pro vers la dernière version, 2.54.2, dès que possible.

Les utilisateurs de Wordfence Premium ont reçu une nouvelle règle de pare-feu le 2 avril 2020 pour se protéger contre les exploits ciblant ces vulnérabilités. Les utilisateurs de Wordfence utilisant toujours la version gratuite recevront la règle après trente jours le 2 mai 2020.


MapPress Maps for WordPress permet aux propriétaires de sites d’ajouter des cartes personnalisées sur leur site, en utilisant à la fois l’API Google Maps et le moteur de dépliant open-source. Les versions gratuite et pro de ce plugin ont enregistré des actions AJAX appelant des fonctions sans vérification de capacité et vérification de nonce. Les crochets AJAX affectés:

add_action('wp_ajax_mapp_delete', array(__CLASS__, 'ajax_delete'));
add_action('wp_ajax_mapp_save', array(__CLASS__, 'ajax_save'));

En tant que tel, il était possible pour un attaquant connecté avec des autorisations minimales, comme un abonné, d’ajouter une carte contenant du JavaScript malveillant à une publication ou une page arbitraire en envoyant un $_POST demande à wp-admin/admin-ajax.php avec le action paramètre défini sur mapp_save, la postid paramètre défini sur le post auquel ajouter la carte, et map paramètre contenant des données JSON représentant la carte à ajouter. Un code JavaScript malveillant pourrait être ajouté au title et body les paramètres d’un «point d’intérêt» dans la carte enregistrée, qui serait exécuté chaque fois qu’un visiteur du site cliquait sur la broche de cartographie indiquant ce point d’intérêt (POI). Alternativement, si le paramètre global pour «Afficher une liste de POI avec chaque carte» était activé, le JavaScript serait exécuté immédiatement lors de la visite d’une page avec une carte impactée.

Cette vulnérabilité pourrait rediriger un visiteur du site vers un site malveillant, ou même utiliser une session administrateur pour reprendre le site en ajoutant un utilisateur administratif malveillant.

La fonction vulnérable:

   static function ajax_save() {
       ob_start();

       $mapdata = (isset($_POST['map'])) ? json_decode(stripslashes($_POST['map']), true) : null;
       $postid = (isset($_POST['postid'])) ? $_POST['postid'] : null;

       if (!$mapdata)
           Mappress::ajax_response('Internal error, your data has not been saved!');

       $map = new Mappress_Map($mapdata);
       $mapid = $map->save($postid);

       if ($mapid === false)
           Mappress::ajax_response('Internal error, your data has not been saved!');

       do_action('mappress_map_save', $mapid);     // Use for your own developments

       // Return saved mapid
       Mappress::ajax_response('OK', array('mapid' => $mapid));
   }

Alternativement, un attaquant pourrait supprimer une carte existante en envoyant un $_POST demande à wp-admin/admin-ajax.php avec le action paramètre défini sur mapp_delete et le mapid paramètre de la carte à supprimer. Bien que cela soit beaucoup moins impactant, il pourrait toujours être utilisé par un attaquant pour supprimer l’une des cartes d’origine sur le site, ce qui pourrait inciter un administrateur à enquêter et à déclencher un script inséré dans une carte malveillante.

La fonction vulnérable:

   static function ajax_delete() {
       ob_start();

       $mapid = (isset($_POST['mapid'])) ? $_POST['mapid'] : null;
       $result = Mappress_Map::delete($mapid);

       if (!$result)
           Mappress::ajax_response("Internal error when deleting map ID '$mapid'!");

       do_action('mappress_map_delete', $mapid);   // Use for your own developments
       Mappress::ajax_response('OK', array('mapid' => $mapid));
   }

La version pro du plugin MapPress offre la possibilité de créer des modèles contrôlant la façon dont les cartes sont affichées. Il enregistre ces modèles sous forme de fichiers .php personnalisés. Malheureusement, le plugin a enregistré plusieurs actions AJAX qui ont appelé des fonctions sans vérification de capacité ou vérification de nonce:

add_action('wp_ajax_mapp_tpl_get', array(__CLASS__, 'ajax_get'));
add_action('wp_ajax_mapp_tpl_save', array(__CLASS__, 'ajax_save'));
add_action('wp_ajax_mapp_tpl_delete', array(__CLASS__, 'ajax_delete'));

Notez que bien que les noms de certaines de ces fonctions soient identiques aux fonctions de la vulnérabilité précédente, ils se trouvent dans un autre fichier et appartiennent à une classe différente. Le fichier contenant ce code vulnérable était présent dans les versions gratuite et pro du plugin MapPress, mais n’était actif que dans la version pro.

En tant que tel, il était possible pour un attaquant authentifié avec des autorisations minimales de télécharger un fichier PHP exécutable tel qu’une porte dérobée ou une webshell. Cela pourrait facilement conduire à une prise de contrôle complète du site, car un attaquant disposant d’un accès par porte dérobée pourrait alors modifier n’importe quel fichier du site, télécharger des fichiers supplémentaires ou se connecter à la base de données et insérer un utilisateur administratif.

Un attaquant pourrait exploiter cette vulnérabilité en envoyant un $_POST demande à wp-admin/admin-ajax.php avec le action paramètre défini sur mapp_tpl_save, la name paramètre défini sur le nom de base du fichier qu’ils voulaient créer, et content paramètre défini sur du code PHP exécutable. Ce fichier serait alors créé et pourrait être exécuté à partir du répertoire du thème actuellement actif, entraînant l’exécution de code à distance.

La fonction vulnérable:

   static function ajax_save() {
       $name = (isset($_POST['name'])) ? $_POST['name'] : null;
       $content = (isset($_POST['content'])) ? stripslashes($_POST['content']) : null;
       $filepath = get_stylesheet_directory() . '/' . $name . '.php';

       $result = @file_put_contents($filepath, $content);
       if ($result === false)
           Mappress::ajax_response('Unable to save');

       // Return filepath after save
       Mappress::ajax_response('OK', $filepath);
   }

Un attaquant authentifié pourrait également supprimer tout fichier PHP existant sur le site en envoyant un $_POST demande à wp-admin/admin-ajax.php avec le action paramètre défini sur mapp_tpl_delete, et le name paramètre défini sur le nom de base du fichier à supprimer.

Par exemple, pour supprimer wp-config.php une attaque de traversée de répertoire pourrait être utilisée, avec le name paramètre défini sur ../../../wp-config. Cela entraînerait la réinitialisation du site, auquel cas un attaquant pourrait prendre le contrôle du site en le configurant à partir de zéro et en le connectant à une base de données malveillante hébergée à distance.

La fonction vulnérable:

   static function ajax_delete() {
       $name = (isset($_POST['name'])) ? $_POST['name'] : null;
       $filepath = get_stylesheet_directory() . '/' . $name . '.php';

       $result = @unlink($filepath);
       if ($result === false)
           Mappress::ajax_response('Unable to delete');

       Mappress::ajax_response('OK');
   }

Enfin, un attaquant authentifié pourrait visualiser le contenu de tout fichier PHP existant sur le site en envoyant un $_GET demande à wp-admin/admin-ajax.php avec le action paramètre défini sur mapp_tpl_get, et le name paramètre du fichier à divulguer. Par exemple, pour afficher le contenu de wp-config.php, un attaquant pourrait name paramètre à ../../../../wp-config. Cela pourrait permettre à un attaquant de déterminer les informations d’identification de la base de données du site. Si la base de données du site autorisait l’accès à distance, l’attaquant pourrait alors l’utiliser pour ajouter un utilisateur administratif ou apporter toute autre modification souhaitée à la base de données, jusqu’à la suppression de presque tout le contenu du site.

La fonction vulnérable:

   static function ajax_get() {
       $name = (isset($_GET['name'])) ? $_GET['name'] : null;

       $filename = $name . '.php';
       $filepath = get_stylesheet_directory() . '/' . $filename;

       $html = @file_get_contents($filepath);
       $standard = @file_get_contents(Mappress::$basedir . "/templates/$filename");

       if (!$standard)
           Mappress::ajax_response('Invalid template');

       $template = new Mappress_Template(array(
           'name' => $name,
           'content' => ($html) ? $html : $standard,
           'path' => $filepath,
           'standard' => $standard,
           'exists' => ($html) ? true : false
       ));

       Mappress::ajax_response('OK', $template);
   }

Calendrier de divulgation

1 avril 2020 – Wordfence Threat Intelligence découvre et analyse les vulnérabilités.
2 avril 2020 – Règle de pare-feu publiée pour les utilisateurs de Wordfence Premium. Contact initial avec le développeur du plugin. Le développeur publie le correctif avant la fin de la journée.
2 mai 2020 – La règle de pare-feu devient disponible pour les utilisateurs gratuits de Wordfence.

Conclusion

Dans l’article d’aujourd’hui, nous avons détaillé deux vulnérabilités dans le plug-in MapPress Maps pour WordPress, y compris un Cross-Site Scripting (XSS) stocké et une vulnérabilité plus critique d’exécution de code à distance (RCE), de divulgation de fichiers et de suppression de fichiers. Ces vulnérabilités ont été entièrement corrigées dans la version 2.53.9 et nous recommandons fortement à tous les utilisateurs de ce plugin de passer immédiatement à la dernière version disponible. Sites en cours d’exécution Wordfence Premium sont protégés contre ces vulnérabilités depuis le 2 avril 2020. Les sites exécutant toujours la version gratuite de Wordfence recevront la mise à jour des règles de pare-feu le 1er mai 2020.

Un merci spécial à Chris Richardson, le développeur du plugin MapPress Maps pour WordPress, pour sa gestion extrêmement rapide et professionnelle de notre divulgation. Corriger une vulnérabilité le même jour que la révélation de vulnérabilité est reçue par le développeur est une réponse exemplaire.


Source link