Lab note: Lobby Board was reproduced in an authorized lab. The flag appears as WEBVERSE{REDACTED}. Session cookies, clearance values, and raw evidence containing secrets are not published.

Executive Summary

The WebVerse Lobby Board challenge exposed a public Next.js build manifest that mapped application routes to client-side chunks. The visible interface did not advertise an administrative area, yet the manifest disclosed a hidden /_admin route and its dedicated JavaScript chunk. The parent route itself returned an application-level 404, but the disclosed chunk enumerated four administrative child routes and identified /_admin/board with guard: null.

I requested /_admin/board without Cookie or Authorization. The server returned HTTP 200 and the real submissions board with moderation statistics, build and runtime details, and the lab flag. Chromium rendered the page, and curl returned the same content.

Confirmed finding: An anonymous request to GET /_admin/board receives the real administrative submissions board. The root cause is missing server-side authentication. Public route and guard metadata are discovery enablers; unauthorized information exposure is the confirmed consequence.

Finding Snapshot

FieldValue
VulnerabilityMissing authentication on a privileged administrative route
Affected endpointGET /_admin/board
Authentication stateAnonymous; Cookie and Authorization headers absent
Primary proofCaido Replay request/response differential
Additional checksChromium rendering and curl reproduction
Primary classificationCWE-306: Missing Authentication for Critical Function
Secondary consequenceCWE-200: Exposure of Sensitive Information to an Unauthorized Actor
OWASP categoryA07:2025, Authentication Failures
ResultSolved / verified; flag redacted as WEBVERSE{REDACTED}

1. Scope and Prerequisites

Testing stayed inside the active WebVerse Lobby Board lab. All runtime results were collected again from the fresh instance. Older notes were used only to plan which evidence to capture.

Scope Boundaries

  • Read-only testing against the active WebVerse challenge host
  • No production organization, third-party user, or real bug-bounty asset was tested
  • Testing stopped after the intended challenge objective was confirmed
  • Session-guarded sibling routes were not accessed and are not claimed to be vulnerable

Prerequisites

  • An active, authorized WebVerse Lobby Board instance
  • Chromium configured through Caido for request capture and Replay validation
  • A terminal with curl to repeat the HTTP request
  • A fresh evidence set from the current instance; expired hostnames and previous flags must not be reused
  • A redaction workflow for flags, cookies, tokens, and raw evidence files

2. Application and Request-Flow Baseline

Lobby Board presented a public directory of one-click starter templates. The visible interface appeared to expose ordinary routes such as templates, integrations, blog, documentation, login, signup, submit, and collections. Its HTML nevertheless loaded the standard Next.js build-manifest asset.

Public landing page
  -> /_next/static/chunks/_buildManifest.js
  -> hidden /_admin route
  -> /_next/static/chunks/pages/_admin/admin-chunk.js
  -> /_admin/board with guard: null
  -> anonymous GET /_admin/board
  -> administrative submissions board and WEBVERSE{REDACTED}

Finding a route name in a public asset was only a lead. The real question was whether the server required authentication when that route was requested directly.

3. Landing-Page Baseline

I first captured a normal visit to the root page in Caido. This recorded the lab host, method, path, and normal HTML response.

GET / HTTP/1.1
Host: <LAB_HOST>

Caido baseline request confirming the active Lobby Board host and the initial GET request.

Figure 1: Caido baseline request confirming the active Lobby Board host and the initial GET / request.

The server returned HTTP 200 with text/html content, identified the application as Lobby Board, and disclosed Express through the X-Powered-By header. The end of the HTML document loaded main.js and _buildManifest.js.

<script src="/_next/static/chunks/main.js" defer></script>
<script src="/_next/static/chunks/_buildManifest.js" defer></script>

Landing-page HTML exposing the Next.js build-manifest path and the Lobby Board version footer.

Figure 2: Landing-page HTML exposing the Next.js build-manifest path and the lobby-board v0.18.4 footer.

Baseline result: The HTML linked the build manifest directly. The path was not guessed or copied from an expired instance.

4. Build Manifest Route Disclosure

The manifest request observed in browser traffic was selected and reproduced in Caido Replay without modification.

GET /_next/static/chunks/_buildManifest.js HTTP/1.1
Host: <LAB_HOST>

Caido request for the public Next.js build manifest with the cookie value permanently raster-redacted.

Figure 3: Caido request for the public Next.js build manifest. The cookie value is permanently raster-redacted.

The server returned HTTP 200 and application/javascript content. The manifest listed ordinary public routes and also mapped a hidden /_admin entry to a dedicated admin page chunk. The same route appeared in sortedPages.

"/_admin": [
  s, a, b,
  "static/chunks/pages/_admin/admin-chunk.js"
]

sortedPages: ["/", "/_admin", "/blog", "/blog/[slug]", ...]

Build-manifest response exposing the hidden admin route, dedicated chunk, and sortedPages inventory.

Figure 4: Build-manifest response exposing /_admin, the admin chunk, and the sortedPages inventory.

Discovery result: The manifest proved that the current public build contained an administrative route. It did not, by itself, prove an authentication failure.

5. Parent Route Negative Control

Before following the chunk to child routes, I tested the parent route as a negative control. A clean root request was copied into Replay and only the path changed to /_admin.

GET /_admin HTTP/1.1
Host: <LAB_HOST>

Replay request to the admin parent route with the cookie value raster-redacted.

Figure 5: Replay request to /_admin; the cookie value is raster-redacted.

The application returned HTTP 404 with its own Lobby Board not-found page. The response contained the expected application branding and the heading Page not found, confirming an application-level result rather than a network or proxy error.

HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8
<title>Not found - Lobby Board</title>
<h1>Page not found</h1>

Application-level 404 response for the admin parent route.

Figure 6: Application-level 404 response used as the parent-route negative control.

Negative-control interpretation: GET /_admin returning 404 closes only that parent index route. It does not prove that /_admin/* children are absent, especially when the current build exposes a dedicated admin chunk.

6. Admin Chunk Analysis

I requested the chunk path listed by the manifest instead of enumerating unrelated administrative paths.

GET /_next/static/chunks/pages/_admin/admin-chunk.js HTTP/1.1
Host: <LAB_HOST>

Caido request for the admin page chunk identified by the active build manifest.

Figure 7: Caido request for the admin page chunk identified by the current build manifest.

The JavaScript response disclosed four administrative child routes, their labels, and their client-side guard values.

"/_admin/board": {
  file: "/_admin/board",
  label: "Submissions board",
  guard: null
},
"/_admin/board/review": { guard: "session" },
"/_admin/users": { guard: "session" },
"/_admin/audit": { guard: "session" }

Admin chunk exposing child routes and guard null for the submissions board while sibling routes use session guards.

Figure 8: Admin chunk exposing child routes and guard: null for /_admin/board while sibling routes use session guards.

Why this route mattered: guard: null made /_admin/board the best candidate to test. Client-side metadata is not an authorization control, so I treated it as a lead, not proof.

7. Anonymous Access Validation

A clean request was copied into Caido Replay and the path was changed to /_admin/board. The Cookie header was removed and no Authorization header was present. This isolated the request from both application session state and the previously observed clearance cookie.

GET /_admin/board HTTP/1.1
Host: <LAB_HOST>

[No Cookie header]
[No Authorization header]

Anonymous Caido Replay request to the submissions board with no Cookie or Authorization header.

Figure 9: Anonymous Caido Replay request to /_admin/board with no Cookie or Authorization header.

The server returned HTTP 200 and an HTML document titled Lobby Board - admin / board. The response was not a redirect, login page, generic shell, or not-found page; it identified the administrative submissions board directly.

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
<title>Lobby Board - admin / board</title>

HTTP 200 response for the anonymous request including the administrative page title.

Figure 10: HTTP 200 response for the anonymous request, including the administrative page title.

The body contained operational queue data and current runtime information. The same page returned the challenge flag, which is redacted in this public document.

admin - submissions board
build 0.18.4 - node v20.20.2 - uptime 1297s

Pending review: 14
Auto-approved (24h): 62
Rejected (24h): 9

flag: WEBVERSE{REDACTED}

Privileged board content returned anonymously including queue statistics runtime metadata and a raster-redacted flag.

Figure 11: Privileged board content returned anonymously, including queue statistics, runtime metadata, and the redacted flag.

Confirmed missing authentication: A request without Cookie or Authorization received the real administrative board. The absent credentials and privileged page content confirm the finding together.

8. Reproduction Commands and Payloads

The following blocks contain only request shapes and command-line actions verified during the fresh authorized reproduction. No injection payload was required: the security boundary was tested through route-specific requests, a parent-route negative control, and an anonymous request-state check. The dynamic target value uses <LAB_HOST>; the flag remains WEBVERSE{REDACTED}.

8.1 Baseline Requests

R-01: landing-page baseline

GET / HTTP/1.1
Host: <LAB_HOST>

Expected result: HTTP 200 with Lobby Board HTML and a reference to /_next/static/chunks/_buildManifest.js. This baseline does not prove an authorization weakness.

R-02: build-manifest request

GET /_next/static/chunks/_buildManifest.js HTTP/1.1
Host: <LAB_HOST>

Expected result: HTTP 200 JavaScript mapping /_admin to static/chunks/pages/_admin/admin-chunk.js and listing /_admin in sortedPages. Route disclosure is a discovery signal, not proof of missing authentication.

8.2 Negative Control

R-03: parent-route control

GET /_admin HTTP/1.1
Host: <LAB_HOST>

Expected result: an application-level HTTP 404 with the Lobby Board not-found page. This rules out only GET /_admin; child routes can still exist.

8.3 Disclosed-Route Follow-Up

R-04: admin-chunk inspection

GET /_next/static/chunks/pages/_admin/admin-chunk.js HTTP/1.1
Host: <LAB_HOST>

Expected result: HTTP 200 JavaScript exposing /_admin/board with guard: null while the disclosed sibling routes use guard: "session". This client-side value prioritizes the candidate; it is not server-side proof.

8.4 Verified Proof Request

R-05: anonymous administrative-board request

GET /_admin/board HTTP/1.1
Host: <LAB_HOST>

[No Cookie header]
[No Authorization header]

Expected result: HTTP 200 plus the admin page title, queue statistics, runtime details, and WEBVERSE{REDACTED}. The missing credentials and privileged response together confirm the issue.

8.5 Command-Line Reproduction

The verified terminal reproduction requested the same resource without configuring a cookie jar or an Authorization header. The public transcription retains the request shape, replaces the dynamic target, and redacts the flag in displayed output.

curl -sS -i \
  'https://<LAB_HOST>/_admin/board' \
| sed -E 's/WEBVERSE\{[^}]+\}/WEBVERSE{REDACTED}/g' \
| grep -E 'HTTP/|<title>|admin - submissions board|build 0\.18\.4|Pending review|Auto-approved|Rejected|flag:'

Expected result: HTTP 200 with the admin title, queue values, runtime details, and a redacted flag. The command repeats the resource request; the nearby Caido capture remains the proof that authentication headers were absent.

8.6 Expected Result and Evidence Boundary

  • Payload inventory: not applicable. No user-controlled injection payload was used in this reproduction.
  • R-01 through R-04 identify the active build, route hierarchy, and best candidate.
  • R-05 proves that the privileged board is rendered for an anonymous request.
  • The curl command reproduces this resource only and does not test sibling routes.
  • Neither route disclosure, guard: null, the parent 404, nor HTTP 200 alone is sufficient; the complete evidence chain is required.

9. Browser and curl Checks

Chromium Rendering

The same route was opened directly in Chromium. The address bar showed the active /_admin/board URL, and the page rendered the same queue values and runtime metadata seen in Caido.

Chromium rendering of the anonymously accessible admin submissions board with the flag raster-redacted.

Figure 12: Chromium rendering of the anonymously accessible admin submissions board with the flag redacted.

The browser showed a higher uptime because the process kept running between requests. The route, build version, Node.js version, queue values, and page title still match. Caido records that the HTTP request had no credentials, while Chromium shows that the response is a working application page.

curl Reproduction

A terminal request repeated the result outside Caido and the browser. Section 8.5 includes the redacted command with the route and output handling, but omits the temporary host and private local file paths.

Terminal verification reproducing HTTP 200 and privileged content after authentication headers were suppressed.

Figure 13: Terminal verification reproducing HTTP 200 and privileged content after Cookie and Authorization headers were suppressed; the flag is redacted.

Public evidence handling: The screenshot records the original local evidence workflow, where tee captured raw output before display redaction. That private raw file is intentionally excluded from the public document and must not be copied into blog assets.

10. WebVerse Solved-State Context

The WebVerse challenge page displayed Lobby Board as SOLVED and identified the challenge as Medium difficulty in the Reconnaissance category.

WebVerse challenge page showing Lobby Board in the solved state.

Figure 14: WebVerse challenge page showing Lobby Board in the solved state.

The page shows a solved date of 27 July 2026, while this reproduction was performed on 28 July. The screenshot proves only that the account had solved the lab before. The fresh response was collected again through Caido, Chromium, and curl.

11. Technical Root Cause and Classification

The public manifest and admin chunk made the route discoverable, but disclosure alone was not the vulnerability. The confirmed root cause was that the server rendered a privileged administrative resource before requiring an authenticated and authorized identity.

LayerObserved RoleSecurity Meaning
Discovery enablerPublic _buildManifest.js exposed /_admin.Identified a hidden route; not proof of access.
Prioritization signalAdmin chunk exposed child routes and guard values.guard: null selected the strongest candidate; client metadata is not enforcement.
Root causeGET /_admin/board returned privileged content anonymously.Missing server-side authentication on a critical function (CWE-306).
ConsequenceQueue statistics, runtime metadata, and the flag were exposed.Sensitive information reached an unauthorized actor (CWE-200 consequence).

Observed vulnerable flow:

request -> /_admin/board -> render administrative board

Required control flow:

request -> authenticate session -> authorize admin role -> render board

Security boundary: Client-side route metadata such as guard: "session" or guard: null may influence presentation, but it cannot enforce access. Every privileged route must validate authentication and authorization on the server.

Classification references: CWE-306 · CWE-200 · OWASP A07:2025

12. Evidence Interpretation and False-Positive Controls

ControlWhat It ProvedWhat It Did Not Prove
Manifest route disclosureThe active public build contained /_admin.It did not prove authentication was missing.
Client guard metadataguard: null prioritized /_admin/board.It was not runtime or server-side proof.
Parent 404GET /_admin had no parent index page.It did not close the /_admin/* subtree.
HTTP 200The request completed successfully.Status alone does not show that the page is privileged.
Caido request stateCookie was removed and Authorization was absent.It did not alone prove the body was administrative.
Browser renderingThe document was a working application page.The browser view alone does not prove that request headers were absent.
curl verificationA separate client reproduced the endpoint and content with auth headers suppressed.It did not expand the finding to untested sibling routes.
Sibling routesThey were disclosed as session-guarded.They were not accessed and are not claimed vulnerable.

13. Impact

In the reproduced lab, an anonymous user could read a privileged submissions board containing moderation queue counts, the application build identifier, the Node.js runtime version, process uptime, and the challenge flag.

In a real application, severity would depend on the board’s data and capabilities. A comparable failure could expose pending submissions, internal moderation decisions, user or tenant information, operational metrics, or privileged actions. This report does not assume broader administrative access and does not claim that the untested sibling routes were accessible.

Impact qualification: The confirmed impact is limited to data returned by /_admin/board. Broader administrative access is a separate hypothesis that would require its own authorized testing.

14. Remediation

14.1 Enforce Server-Side Authentication

Require a valid authenticated session before any /_admin/* handler or rendering logic runs. Anonymous requests should receive a consistent 401, 403, or controlled login redirect according to the application architecture.

14.2 Enforce Role and Permission Authorization

Authentication alone is insufficient. The server must verify that the authenticated identity has the administrative role or explicit permission required by each route.

14.3 Minimize Public Administrative Metadata

Where architecture permits, keep administrative routes and guard metadata out of the public client bundle. This reduces unnecessary disclosure but must not be treated as a substitute for server-side access control.

14.4 Minimize Administrative Responses

Do not expose runtime versions, process uptime, internal queue statistics, tokens, or secrets unless they are required for an authorized administrative function.

14.5 Add Authorization Regression Tests

CI/CD should maintain an approved public-route inventory and execute an identity/permission matrix for every administrative endpoint.

Anonymous user               -> 401/403 or controlled login redirect
Authenticated non-admin user -> 403
Authorized administrator     -> 200

15. Reproduction Reference

Reproduction contract: Run the sequence against the current authorized instance and preserve the evidence order. The finding is reproduced only when an anonymous request reaches the genuine administrative board. Route disclosure, guard metadata, a parent 404, or HTTP 200 alone is insufficient.

  1. Capture the baseline. Send GET / and record the active host, application identity, and /_next/static/chunks/_buildManifest.js reference.
  2. Resolve the deployed route map. Request the build manifest and confirm that the same active build maps /_admin to its dedicated admin chunk.
  3. Keep the parent-route control. Request GET /_admin and record the application-level 404. Treat it as a result for the parent route only, not proof that child routes are absent.
  4. Convert source disclosure into a test candidate. Retrieve the disclosed admin chunk and identify /_admin/board with guard: null. Use this metadata to prioritize validation, never as proof of access.
  5. Prove the anonymous request state. Request GET /_admin/board with no Cookie or Authorization header and retain the request and response together.
  6. Confirm privileged content. Require HTTP 200 plus the admin title, queue data, runtime details, and the redacted lab flag.
  7. Triangulate and publish safely. Reproduce the resource in Chromium and sanitized curl, keep Caido as the primary proof of header absence, and exclude raw secret-bearing output from public assets.

16. Lessons Learned

The evidence chain produces five transferable lessons for future web application testing:

  • Treat route hierarchy precisely. A parent 404 closes only GET /_admin; it does not close the full /_admin/* subtree.
  • Use client assets for prioritization, not proof. Manifest and guard metadata narrow the search, while the server response determines whether a security boundary failed.
  • Require both anonymous state and privileged content. Missing headers show that the request is anonymous. The admin title, queue data, runtime details, and flag show that the response is privileged.
  • Use each tool for a clear reason. Caido records the anonymous HTTP request, Chromium shows a working page, and curl repeats the resource request.
  • Make publication hygiene part of the workflow. Redact flags and credentials, exclude raw captures, and remove unused embedded assets before release.

17. Final Result and Conclusion

Discovery. The active landing HTML exposed the Next.js build-manifest path. The manifest mapped /_admin to a dedicated page chunk; although GET /_admin returned 404, the chunk disclosed deployed child routes and marked /_admin/board with guard: null. These signals selected the candidate but did not prove the vulnerability.

Validation and verdict. Caido recorded GET /_admin/board without Cookie or Authorization and an HTTP 200 response containing the real submissions board and lab flag. Chromium rendered the page, and curl returned the same resource. This confirms CWE-306: the privileged route lacks server-side authentication.

LAB RESULT
Endpoint: GET /_admin/board
Request state: Anonymous. Cookie and Authorization absent
Primary weakness: CWE-306, Missing Authentication for Critical Function
Flag: WEBVERSE{REDACTED}
Status: SOLVED / VERIFIED