Le 2 mars, notre équipe Threat Intelligence a découvert plusieurs points de terminaison vulnérables dans Importateur de sites prêts à l’emploi, un plugin WordPress installé sur plus de 40 000 sites. Ces failles ont permis à tout utilisateur authentifié, quel que soit son niveau de privilège, la possibilité d’exécuter diverses actions AJAX qui pouvaient réinitialiser les données du site, injecter du JavaScript malveillant dans les pages, modifier les données du personnalisateur de thème, importer des fichiers .xml et .json et activer des plugins, parmi de nombreux d’autres actions.

Nous avons contacté le développeur du plugin le 3 mars 2020, et ils ont été proactifs et rapides à répondre. Ils ont publié des correctifs consistant en des vérifications de nonce et d’autorisations sur presque tous les points de terminaison AJAX avant d’envoyer les détails complets de la vulnérabilité le lendemain matin. Nous avons toujours fourni la divulgation complète et souligné quelques points de terminaison AJAX manqués dans leur version initiale. Ils ont sorti un patch final quelques jours plus tard.

Ceci est considéré comme un problème de sécurité grave qui pourrait conduire à des attaquants qui prennent complètement le contrôle des sites WordPress. Nous vous recommandons vivement de mettre à jour immédiatement la dernière version disponible, 2.2.7.

Les clients de Wordfence Premium ont reçu une nouvelle règle de pare-feu le 2 mars 2020 pour se protéger contre les exploits ciblant cette vulnérabilité. Les utilisateurs gratuits de Wordfence recevront la règle après trente jours, le 1er avril 2020.

Gutenberg & Elementor Templates Importer For Responsive, également appelé Responsive Ready Sites Importer, est un plugin conçu pour importer des modèles et du contenu de site à utiliser avec les constructeurs de pages Gutenberg ou Elementor. Le plugin est très simple à utiliser et fournit une pléthore de modèles parmi lesquels les propriétaires de sites peuvent choisir.

La fonctionnalité d’importation repose sur diverses actions AJAX, avec des fonctionnalités allant de la réinitialisation des données du site avant une importation complète à l’importation de fichiers .xml et .json pour fournir des données pour l’importation. Nous avons découvert 23 points de terminaison vulnérables, et la majorité d’entre eux ont été trouvés dans le fichier /class-responsive-ready-sites-importer.php.

/**
 * Constructor.
 *
 * @since 1.0.0
 */
public function __construct() {

   add_action( 'init', array( $this, 'load_importer' ) );

   $responsive_ready_sites_importers_dir = plugin_dir_path( __FILE__ );
   require_once $responsive_ready_sites_importers_dir . 'class-responsive-ready-sites-importer-log.php';
   include_once $responsive_ready_sites_importers_dir . 'class-responsive-ready-sites-widgets-importer.php';
   include_once $responsive_ready_sites_importers_dir . 'class-responsive-ready-sites-options-importer.php';

   // Import AJAX.
   add_action( 'wp_ajax_responsive-ready-sites-import-set-site-data-free', array( $this, 'import_start' ) );
   add_action( 'wp_ajax_responsive-ready-sites-import-xml', array( $this, 'import_xml_data' ) );
   add_action( 'wp_ajax_responsive-ready-sites-import-wpforms', array( $this, 'import_wpforms' ) );
   add_action( 'wp_ajax_responsive-ready-sites-import-customizer-settings', array( $this, 'import_customizer_settings' ) );
   add_action( 'wp_ajax_responsive-ready-sites-import-widgets', array( $this, 'import_widgets' ) );
   add_action( 'wp_ajax_responsive-ready-sites-import-options', array( $this, 'import_options' ) );
   add_action( 'wp_ajax_responsive-ready-sites-import-end', array( $this, 'import_end' ) );

   add_action( 'responsive_ready_sites_import_complete', array( $this, 'clear_cache' ) );

   include_once $responsive_ready_sites_importers_dir . 'batch-processing/class-responsive-ready-sites-batch-processing.php';

   // Reset Customizer Data.
   add_action( 'wp_ajax_responsive-ready-sites-reset-customizer-data', array( $this, 'reset_customizer_data' ) );
   add_action( 'wp_ajax_responsive-ready-sites-reset-site-options', array( $this, 'reset_site_options' ) );
   add_action( 'wp_ajax_responsive-ready-sites-reset-widgets-data', array( $this, 'reset_widgets_data' ) );

   // Reset Post & Terms.
   add_action( 'wp_ajax_responsive-ready-sites-delete-posts', array( $this, 'delete_imported_posts' ) );
   add_action( 'wp_ajax_responsive-ready-sites-delete-wp-forms', array( $this, 'delete_imported_wp_forms' ) );
   add_action( 'wp_ajax_responsive-ready-sites-delete-terms', array( $this, 'delete_imported_terms' ) );

   if ( version_compare( get_bloginfo( 'version' ), '5.0.0', '>=' ) ) {
      add_filter( 'http_request_timeout', array( $this, 'set_timeout_for_images' ), 10, 2 );
   }
}

En utilisant le import_start fonction liée à la wp_ajax_responsive-ready-sites-import-set-site-data-free comme exemple ci-dessous. Il peut être démontré qu’il y avait un manque de contrôles de capacité et de contrôles nonce dans le cadre des fonctions. Cela était évident dans toutes les fonctions identifiées déclenchées par les actions AJAX enregistrées que nous avons trouvées vulnérables.

/**
 * Start Site Import
 *
 * @since  1.0.0
 * @return void
 */
public function import_start() {

          $demo_api_uri = isset( $_POST['api_url'] ) ? esc_url( $_POST['api_url'] ) : ''; //phpcs:ignore

   if ( ! empty( $demo_api_uri ) ) {

      $demo_data = self::get_responsive_single_demo( $demo_api_uri );
      if ( ! $demo_data['success'] ) {
         wp_send_json( $demo_data );
      }

      update_option( 'responsive_ready_sites_import_data', $demo_data );

      if ( is_wp_error( $demo_data ) ) {
         wp_send_json_error( $demo_data->get_error_message() );
      } else {
         do_action( 'responsive_ready_sites_import_start', $demo_data, $demo_api_uri );
      }

      wp_send_json_success( $demo_data );

   } else {
      wp_send_json_error( __( 'Request site API URL is empty. Try again!', 'responsive-addons' ) );
   }

}

Toutes les actions vulnérables pourraient être appelées sur simple demande /wp-admin/admin-ajax.php?action=[Vulnerable-Action] ainsi que les paramètres appropriés définis, par tout utilisateur authentifié, y compris les utilisateurs avec des autorisations minimales au niveau de l’abonné.

Heureusement, dans la dernière version de ce plugin, des vérifications de capacité pour aider à contrôler l’accès et l’exécution, ainsi que la protection CSRF à l’aide de nonces WordPress, ont été implémentées sur tous ces points de terminaison.

Une plongée plus profonde sur quelques points d’extrémité

Bien qu’il y ait plusieurs critères d’évaluation non protégés, certains étaient un peu plus inquiétants que d’autres.

L’action AJAX wp_ajax_responsive-ready-sites-import-xml déclenche une fonction qui importe un fichier XML à utiliser pour fournir des données dans le cadre du processus d’importation. Ensuite, l’action AJAX wp_ajax_responsive-wxr-import déclencherait la fonction qui importe toutes les données du fichier XML précédemment importé. L’utilisation de ces deux actions ensemble pourrait permettre à un attaquant d’importer un fichier XML contenant des charges utiles malveillantes telles que de nouvelles pages sur le site. Les charges utiles malveillantes seraient alors exécutées chaque fois qu’un utilisateur accède à la page nouvellement importée. Cela pourrait entraîner des redirections de sites malveillants et la création d’utilisateurs administratifs malveillants, entre autres conséquences.

Les actions AJAX wp_ajax_responsive-ready-sites-import-options, wp_ajax_responsive-ready-sites-import-widgets, et wp_ajax_responsive-ready-sites-import-customizer-settings fonctions déclenchées qui importent des widgets, des options de site et des données de personnalisation de site. Ceux-ci pourraient être utilisés par un attaquant pour remplacer les données du site par des données malveillantes de leur choix.

Une brève note aux propriétaires de sites et aux développeurs WordPress

Propriétaires du site. Les points de terminaison AJAX vulnérables sont, malheureusement, une vulnérabilité très courante parmi les plugins et les thèmes WordPress. Nous vous recommandons vivement de désactiver l’inscription des utilisateurs sur votre site si cela n’est pas nécessaire pour la fonctionnalité du site. Si votre site exécute un plugin ou un thème avec un point de terminaison AJAX vulnérable, cela interdira à tout attaquant de pouvoir enregistrer un compte, se connecter, puis exécuter des attaques contre ces points de terminaison vulnérables qui pourraient potentiellement compromettre votre site.

Il est également fortement recommandé de s’assurer que vos plugins et thèmes sont à jour à tout moment car ces vulnérabilités sont souvent immédiatement découvertes et corrigées. Dans les cas où un correctif n’est pas publié rapidement, il est important que vous disposiez d’un pare-feu d’application Web, tel que celui fourni par Wordfence, pour aider à fournir une protection pendant la période intermédiaire où une vulnérabilité pourrait être découverte et attaquée activement avant il a été complètement corrigé.

Développeurs. Il est extrêmement important d’ajouter des vérifications de capacités et une protection CSRF sur les fonctions contrôlées par les actions AJAX dans les plugins et les thèmes. Les utilisateurs de niveau abonné et supérieur ont la possibilité d’exécuter ces actions si les mesures de sécurité appropriées ne sont pas en place. De nombreux sites WordPress permettent un enregistrement ouvert, créant une grande surface d’attaque pour ces vulnérabilités qui sont généralement très faciles à exploiter.

Utilisez des fonctions comme current_user_can() pour vérifier la capacité de l’utilisateur sur les actions avec wp_create_nonce() et wp_verify_nonce() pour vérifier la légitimité de la source d’une demande de protection contre CSRF sur toutes les fonctions AJAX.

Pour voir à quel point ces vulnérabilités sont courantes, vous pouvez consulter certaines de nos vulnérabilités récemment identifiées dans les actions AJAX non protégées dans Popup Builder, Importer exporter des utilisateurs WordPress, 301 redirections – Easy Redirect Manager, et RegistrationMagic. En tant que développeur de plugins, il est important de prendre des mesures préventives contre la création de ces vulnérabilités, tout comme il est important de vous protéger contre celles-ci en tant que propriétaire de site.

Calendrier de divulgation

2 mars 2020 – Découverte initiale et analyse de vulnérabilité. Nous publions une règle de pare-feu pour les clients Wordfence Premium.
3 mars 2020 – Nous faisons notre première tentative de contact avec l’équipe de développement du plugin. Le développeur répond et confirme que nous les avons atteints via la boîte de réception appropriée.
4 mars 2020 – Nous envoyons les détails complets de la divulgation. Le développeur répond et indique que toutes les vulnérabilités ont été corrigées.
4-5 mars 2020 – Nous analysons plus en détail les correctifs et découvrons quelques actions AJAX non protégées. Nous informons le développeur.
11 mars 2020 – Le développeur publie le correctif final suffisant.
1 avril 2020 – Les utilisateurs de Wordfence gratuits reçoivent une règle de pare-feu.

Conclusion

Dans le post d’aujourd’hui, nous avons détaillé plusieurs failles liées aux actions AJAX non protégées dans le plugin Responsive Ready Sites Importer. Ces failles ont été entièrement corrigées dans la version 2.2.6. Nous recommandons aux utilisateurs de mettre à jour la dernière version disponible immédiatement. Sites en cours d’exécution Wordfence Premium sont protégés contre les attaques contre cette vulnérabilité depuis le 2 mars 2020. Les sites exécutant la version gratuite de Wordfence recevront la mise à jour des règles de pare-feu le 1er avril 2020.


Source link