Skip to content
Noroxi
Research7 min read

ElementsKit Lite 4.0.7: Unauthenticated Template Disclosure

A missing-authorization flaw in ElementsKit Lite 4.0.7 lets anonymous visitors render published Elementor templates through a megamenu REST route.

Noroxi TeamPenetration testing and security consulting

Abstract. ElementsKit Lite 4.0.7, an Elementor addon pack with more than a million active installs, ships a broken-access-control flaw (CWE-862, Missing Authorization). Its megamenu REST route registers with an open permission callback and leaves authorization to each per-action method. One of those methods renders any published Elementor document by id, with no capability check and no nonce. An unauthenticated visitor can therefore read templates the site meant to keep behind an editing capability or behind display conditions. What follows covers the root cause, the secure-coding lesson, and the defensive steps for site owners and developers. Under coordinated disclosure the vendor has been notified privately, and the working proof of concept stays unpublished until a fix ships.

Keywords: ElementsKit Lite, WordPress, broken access control, missing authorization, REST API, Elementor templates, information disclosure, CWE-862.

1. Introduction

Elementor addon packs extend the page builder with widgets, templates and layout tools, and ElementsKit Lite is among the most widely deployed of them, past 1,000,000 active installs. Scale like that makes a plugin worth close study: one missing check repeats across an enormous population of sites, and template and design content tends to be treated as private by owners even when WordPress technically marks it "published".

The pattern here is a familiar one — a REST route that anyone can reach, which then neglects to re-check authorization in its handler. It is among the most common and most consequential mistakes in the WordPress ecosystem. Developers need to recognise it; site owners need to spot and contain it. The mechanism is described below without a runnable attack.

2. Affected component

PluginElementsKit Lite (Elementor addons) — slug elementskit-lite
Tested version4.0.7 (current at time of testing)
Active installations1,000,000+
Vulnerability typeBroken Access Control / Information Disclosure
CWECWE-862 Missing Authorization / CWE-284
Required privilegeNone — unauthenticated
CVSS 3.1~5.3 (Medium) AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
StatusFresh, confirmed in code on the current version.

3. Technical analysis

The megamenu base route registers with an open permission callback, declaring that each action handles its own authorization:

php
// core/handler-api.php  (Handler_Api::init)register_rest_route(    untrailingslashit('elementskit/v1/' . $this->prefix),    '/(?P<action>\w+)/' . ltrim($this->param, '/'),    [ 'methods' => WP_REST_Server::ALLMETHODS,      'callback' => [$this, 'callback'],      'permission_callback' => '__return_true' ]   // all permissions "implemented inside the callback");

'__return_true' as a permission callback is not wrong in itself, but it shifts the full weight of authorization onto every per-action method. The contract holds only while every method does its part. The megamenu content method does not:

php
// modules/megamenu/api.phppublic function get_megamenu_content() {    $menu_item_id = intval($this->request['id']);    // DEFECT: only a publish/password gate — no current_user_can() and no wp_verify_nonce()    if ('publish' !== get_post_status($menu_item_id) || post_password_required($menu_item_id)) {        return '';    }    $output = \ElementsKit_Lite\Utils::render_elementor_content($menu_item_id, true); // renders ANY published doc    return $output;}

Before rendering, the only gate is a publish-status and password check — no capability check (current_user_can), no nonce verification (wp_verify_nonce). And because render_elementor_content() calls Elementor's get_builder_content_for_display() with no post-type restriction, the method renders the HTML of any published Elementor document named by id, elementor_library templates included.

Elementor's own frontend guard (block_template_frontend) normally keeps library templates out of direct view unless the user can edit_posts. Rendering through this unauthenticated route sidesteps that guard entirely. Content the platform meant to withhold from anonymous visitors — templates gated behind display conditions among it — becomes readable with no authentication at all.

4. How the flaw is reached (conceptual)

Two independent safety assumptions sit on either side of this route, and neither holds. The REST layer trusts the handler to enforce authorization; the handler trusts that a publish status makes a document safe to render to anyone. Put together, they leave an unbroken path from an anonymous HTTP request to Elementor's rendering routine.

In WordPress, publish is an editorial state, not an access decision. Plenty of objects are published for internal or conditional use: library templates, design fragments, content shown only when a display condition is met, items linked from no public page. Treating "published" as a stand-in for "public" is the root mistake. Anyone who can send the site an HTTP request — no account, no cookie, no nonce — can make the route render such a document, as long as they name a valid published id. Those ids are small integers, so the pool of candidate documents is in no real sense secret.

The result is a confidentiality exposure: an unauthenticated party can retrieve the rendered markup and styles of templates the owner believed were private. The request sequence, the parameter values and any enumeration procedure stay out of this write-up.

5. Impact assessment

What leaks is unauthenticated access to Elementor library templates and documents meant for contributor-and-above users only, or meant to appear only when their display conditions were satisfied — designs, embedded copy, internal or staged templates. The issue is confidentiality-only; on its own it changes no data and touches no availability.

The matching CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N, roughly 5.3 (Medium). Network reach, low complexity and no need for privilege or user interaction keep exploitability high, while the confidentiality-only impact holds the base score at Medium. The install base raises the practical stakes: a Medium flaw spread over 1,000,000+ sites is a large aggregate exposure.

6. Remediation

The fix is to re-apply Elementor's own view policy inside the handler, before anything renders:

php
// modules/megamenu/api.php — enforce authorization before renderingpublic function get_megamenu_content() {    $menu_item_id = intval($this->request['id']);
    // Mirror Elementor's block_template_frontend(): library templates require an editing capability.    if ('elementor_library' === get_post_type($menu_item_id)        && ! current_user_can('edit_posts')) {        return '';    }
    if ('publish' !== get_post_status($menu_item_id) || post_password_required($menu_item_id)) {        return '';    }
    return \ElementsKit_Lite\Utils::render_elementor_content($menu_item_id, true);}

The route can also — or instead — be narrowed so it renders only menu items actually used in a registered megamenu, rather than any post id. More generally, a route that renders arbitrary documents by id has no business relying on an open permission callback; it should check the caller's capability for the specific object it is about to render.

Until an official fixed release lands, owners should treat the feature as exposed and apply the containment steps below.

7. Detection and hardening for site owners

  • Watch the route in your logs. Unauthenticated hits on the plugin's megamenu REST endpoint — above all a run of requests that vary only an id — point to enumeration. Sequential-id access surfacing from one source is worth a look.
  • Apply least privilege to template content. "Published but unlinked" is not a privacy control. If a template holds anything sensitive — internal copy, unreleased designs, staged pages — assume a publish status can be rendered, and keep genuinely sensitive material out of published documents.
  • Turn the feature off if you don't use it. Sites that don't run the ElementsKit megamenu can disable that module, or the plugin, until a fix ships, and shed the attack surface in the meantime.
  • Virtual-patch where you can. A WAF or edge rule can block unauthenticated calls to the specific REST path as a stopgap. That contains the problem; it does not replace the vendor fix.
  • Keep the plugin updated. Install the official fixed release as soon as the vendor publishes it, and subscribe to update alerts rather than leaning on manual checks.

Everything above follows from the mechanics already described; none of it assumes a product feature the analysis did not establish.

8. Broader lesson

The principle is that transport-layer reachability and object-level authorization are separate problems, and both have to be enforced. Declaring permission_callback => '__return_true' and promising to "check inside the callback" is a contract only as strong as its least careful handler; one method that forgets the check reopens the entire route. An editorial state like publish is likewise never an access decision. A secure handler checks the caller's capability for the exact resource in play, at the moment of the action, every time — not inherited from the route, not borrowed from a content status. And where a platform already defines a view policy for a content type — as Elementor does — components that render that type should mirror the policy rather than quietly route around it.

9. Responsible disclosure

The work was done under coordinated disclosure. The vendor has been notified privately and in good faith, and the full technical proof of concept stays out of public release until an official fix is available — or until the agreed disclosure deadline, whichever comes first — with timing coordinated with the maintainer. Nothing that would enable live exploitation appears here.

All testing ran against the public GPL plugin in an isolated, localhost-bound lab. No third-party or production systems were touched. Noroxi LLC conducts authorized security research only, and does not and will not provide operational exploitation material for an unpatched issue.

References


Published for defensive and educational purposes. Noroxi LLC conducts authorized security research only; operational exploit detail is withheld until a fix is available.

Exploited this week · every Monday

New KEV entries, fresh PoCs, WordPress triage and what to do this week. No account needed.

Your address is used only for this email and never shared.

Up next

Essential Blocks: Contributor Reads the Admin's Google Maps API Key