November 18, 2026
The Lock Icon That Lied: Bypassing an “Admins Only” Feature by Simply… Not Being One
A story about a UI control that trusted the wrong thing to enforce its own restriction
By Arunkumarje
3 min read
The setup
Most access-control bugs I'd found on this platform lived purely at the API layer — a role's UI hid a feature cleanly, but the server behind it didn't check who was asking. Annoying, but a familiar shape of bug: "the frontend gates it, the backend forgot to."
This one was different. This time, the bug wasn't hidden behind the UI. It was sitting in plain sight, inside the UI itself — because the UI never actually gated it in the first place.
The feature: Lock
In the platform's Layout Editor, every element on a screen layout — a text box, a clock widget, an image — has a small toolbar with a "Locked" control. Hover over it as an account owner, and the tooltip tells you exactly what it's for:
"Only for admins. Lock items to prevent accidental changes. It can be used in conjunction with the 'Lock insert' feature."
That's about as explicit as a product can be about intent. This control exists specifically so that admins, and only admins, can pin down a layout element so that other, less-trusted staff can't accidentally (or deliberately) move or resize it.
The bypass
I logged in as an account holding the Content & Device Manager role — a real, documented, non-admin role on this platform, one tier below the account owner/admin roles.
I opened a layout in the editor, selected an element, and looked at its toolbar.
The lock control wasn't hidden. It wasn't grayed out. It was sitting right there, fully interactive, exactly as it appears for an admin.
I clicked it. The element locked. I toggled it again. It unlocked. Underneath, the browser sent:
PUT /api/v1/show/show/<show_id>/PUT /api/v1/show/show/<show_id>/with the element's "lock" field set to "sizepos" in the payload — and the server answered:
HTTP/1.1 200 OKHTTP/1.1 200 OK…with the full, updated layout object, change persisted, timestamp bumped. No rejection. No downgrade. No silent no-op. The change took.
Why this one stings more than a typical BAC finding
Most of the authorization gaps I'd found up to this point were "the UI hides it, the API doesn't enforce it" — which at least means someone, somewhere in the stack, remembered there was supposed to be a restriction. You could imagine a junior developer forgetting to add a server-side check while the frontend did its job correctly.
This one fails at the layer that's supposed to be the first line of defense: the UI itself renders an admin-only control for a non-admin role, with no gating logic distinguishing who's allowed to see it, let alone use it. Whatever logic decides "is this user an admin" for display purposes either doesn't exist for this control, or is checking the wrong thing entirely — because Content & Device Manager, a role one step down from admin, sailed right through.
And the control isn't cosmetic. It exists to let an organization say: these layout elements are protected, don't let non-admin staff touch their size or position. If a non-admin role can toggle that lock at will, the entire protective intent of the feature collapses — any org relying on it to safeguard, say, a legally-required disclaimer's position, or a sponsor logo's placement, has no actual guarantee that only admins can override it.
Possibly deeper than one role
During testing, I also observed what appeared to be the same behavior on Restricted Content Manager — a role the platform's own documentation describes as "same as Content Manager, but cannot publish content." If that holds up under the vendor's own verification, it means one of the most deliberately restricted roles on the platform — explicitly denied even the ability to publish — can still override a protection explicitly reserved for admins. That's a meaningfully bigger gap than a single role misconfiguration; it suggests the lock control's visibility logic isn't checking role tier at all.
The fix
This is a case where the UI needs to actually implement the promise in its own tooltip: before rendering the lock control as interactive, check whether the current session's role is genuinely admin-tier, and if not, render it disabled or omit it entirely — exactly the way the rest of this platform's UI already does for dozens of other admin-only features. And since UI gating alone has proven unreliable across this whole audit, the PUT handler for the layout object should independently verify admin status before accepting a change to the lock field, regardless of what the frontend did or didn't show.
Takeaways for other product teams
- A tooltip describing a restriction is not the same as enforcing it. If your UI tells the user a control is admin-only, make sure the render logic actually checked that before drawing the control at all.
- Protective features deserve the same scrutiny as sensitive-data features. A "lock to prevent changes" control feels low-stakes compared to, say, a billing page — but its entire value proposition is the access boundary around it. If that boundary doesn't hold, the feature is actively misleading admins who believe they've secured something they haven't.
- Test your own admin-only affordances from a non-admin seat. It's easy to verify a feature exists and works for the role it was built for. It's just as important to verify it's absent or inert for every role it wasn't built for.