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/boardreceives 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
| Field | Value |
|---|---|
| Vulnerability | Missing authentication on a privileged administrative route |
| Affected endpoint | GET /_admin/board |
| Authentication state | Anonymous; Cookie and Authorization headers absent |
| Primary proof | Caido Replay request/response differential |
| Additional checks | Chromium rendering and curl reproduction |
| Primary classification | CWE-306: Missing Authentication for Critical Function |
| Secondary consequence | CWE-200: Exposure of Sensitive Information to an Unauthorized Actor |
| OWASP category | A07:2025, Authentication Failures |
| Result | Solved / 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
curlto 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>

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>

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>

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]", ...]

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>

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>

Figure 6: Application-level 404 response used as the parent-route negative control.
Negative-control interpretation:
GET /_adminreturning404closes 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>

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" }

Figure 8: Admin chunk exposing child routes and guard: null for /_admin/board while sibling routes use session guards.
Why this route mattered:
guard: nullmade/_admin/boardthe 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]

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>

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}

Figure 11: Privileged board content returned anonymously, including queue statistics, runtime metadata, and the redacted flag.
Confirmed missing authentication: A request without
CookieorAuthorizationreceived 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
curlcommand reproduces this resource only and does not test sibling routes. - Neither route disclosure,
guard: null, the parent404, norHTTP 200alone 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.

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.

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
teecaptured 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.

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.
| Layer | Observed Role | Security Meaning |
|---|---|---|
| Discovery enabler | Public _buildManifest.js exposed /_admin. | Identified a hidden route; not proof of access. |
| Prioritization signal | Admin chunk exposed child routes and guard values. | guard: null selected the strongest candidate; client metadata is not enforcement. |
| Root cause | GET /_admin/board returned privileged content anonymously. | Missing server-side authentication on a critical function (CWE-306). |
| Consequence | Queue 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"orguard: nullmay 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
| Control | What It Proved | What It Did Not Prove |
|---|---|---|
| Manifest route disclosure | The active public build contained /_admin. | It did not prove authentication was missing. |
| Client guard metadata | guard: null prioritized /_admin/board. | It was not runtime or server-side proof. |
| Parent 404 | GET /_admin had no parent index page. | It did not close the /_admin/* subtree. |
| HTTP 200 | The request completed successfully. | Status alone does not show that the page is privileged. |
| Caido request state | Cookie was removed and Authorization was absent. | It did not alone prove the body was administrative. |
| Browser rendering | The document was a working application page. | The browser view alone does not prove that request headers were absent. |
curl verification | A separate client reproduced the endpoint and content with auth headers suppressed. | It did not expand the finding to untested sibling routes. |
| Sibling routes | They 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 HTTP200alone is insufficient.
- Capture the baseline. Send
GET /and record the active host, application identity, and/_next/static/chunks/_buildManifest.jsreference. - Resolve the deployed route map. Request the build manifest and confirm that the same active build maps
/_adminto its dedicated admin chunk. - Keep the parent-route control. Request
GET /_adminand record the application-level404. Treat it as a result for the parent route only, not proof that child routes are absent. - Convert source disclosure into a test candidate. Retrieve the disclosed admin chunk and identify
/_admin/boardwithguard: null. Use this metadata to prioritize validation, never as proof of access. - Prove the anonymous request state. Request
GET /_admin/boardwith noCookieorAuthorizationheader and retain the request and response together. - Confirm privileged content. Require HTTP
200plus the admin title, queue data, runtime details, and the redacted lab flag. - 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
404closes onlyGET /_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
curlrepeats 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