Lab note: Routing Slip was reproduced in a fresh authorised WebVerse lab. The instance hostname, changing runtime values, and objective value are not included. The /_ops/echo route stays visible because it is needed to follow the evidence chain. The objective appears as WEBVERSE{REDACTED}.

Executive Summary

Routing Slip exposed public developer documentation with a link to its OpenAPI file. The file required Bearer authentication by default, but one internal liveness operation used security: []. In OpenAPI, that operation-level setting overrides the global requirement.

One unauthenticated, read-only browser request to the documented operation returned JSON runtime metadata and the current WebVerse objective. No route guessing, fuzzing, credentials, scanner, payload mutation, or write action was required.

CONFIRMED FINDING

A public OpenAPI contract disclosed an internal operational GET function with an explicit authentication override. The deployed operation was reachable without credentials and returned sensitive runtime metadata.

1. Report Profile

FieldVerified value
PlatformWebVerse
LabRouting Slip
StatusFresh runtime reproduction verified; challenge had previously been solved
EvidenceFresh browser evidence and the linked OpenAPI contract
Primary weaknessCWE-306: Missing Authentication for Critical Function
Supporting weaknessCWE-200: Exposure of Sensitive Information to an Unauthorized Actor
curl reproductionNot performed
Write actions / state mutationNone
Requests after objective hit0 target requests

Verified Attack Chain

Normal dashboard visit
  > Visible Developers and API-reference entry points
Public developer documentation
  > Linked current OpenAPI contract
OpenAPI contract
  > Global BearerAuth baseline
Documented internal GET operation
  > Local security: [] override and runtime-metadata response contract
One unauthenticated browser GET
  > JSON runtime metadata plus WEBVERSE{REDACTED}
Stop
  > No further target requests

2. Scope and Evidence Boundary

The reproduction was intentionally limited to the known, documentation-led solution path on a fresh authorised lab instance.

  • I followed the dashboard, developer documentation, OpenAPI file, and live endpoint in that order.
  • The internal operation was requested once, without an Authorization header, Cookie, body, query parameter, credential, or payload mutation.
  • No route fuzzing, scanner, credential guessing, customer-data probing, webhook registration, or other write endpoint was used.
  • The first response containing the objective ended target interaction.
  • The available solved-state image is historical platform state. It is not used to claim a fresh submission or fresh platform acceptance.

The evidence covers one documented operation that responds without authentication. I did not test customer shipments, cross-tenant data, writes, account takeover, SSRF, SQL injection, RCE, or the rest of the API.

3. Step-by-Step Reproduction

3.1 Legitimate Baseline and Developer Entry Point

The fresh instance loaded without authentication and displayed a Developers link plus an API reference in the footer. The documentation route came directly from the application and did not need to be guessed.

Fresh unauthenticated Routing Slip dashboard with visible Developers and API reference navigation

Figure 1: Legitimate baseline. The visible application UI exposes the developer and API-reference entry points. This is discovery context, not vulnerability evidence; the hostname and region are redacted.

3.2 Public Developer Documentation

The Developers link opened public documentation. It described Bearer authentication for customer-data endpoints and linked openapi.json. The page itself is not a vulnerability; it simply explains where the API description came from. I did not run its example curl command.

Public Routing Slip developer portal with Bearer-authentication guidance and the visible openapi.json contract link

Figure 2: Public developer portal. The application itself provides the documentation route, shows the intended Bearer-authentication model, and directly links the live openapi.json contract. The live browser origin and region are excluded; the documentation’s static .example API reference and token variable are retained because they explain the public contract without disclosing a credential.

R-01: developer documentation URL model.

<LAB_ORIGIN>/api/docs

Expected result: public developer documentation containing a direct link to the current API contract.

3.3 Global Bearer Authentication Baseline

The linked OpenAPI 3.0.3 contract defined BearerAuth globally. The scheme is HTTP Bearer with JWT-format tokens, so this is the default authentication policy inherited by operations unless an operation defines its own security requirement.

R-02: public contract URL model.

<LAB_ORIGIN>/api/docs/openapi.json
"security": [
  { "BearerAuth": [] }
],
"securitySchemes": {
  "BearerAuth": {
    "type": "http",
    "scheme": "bearer",
    "bearerFormat": "JWT"
  }
}

Focused OpenAPI contract excerpt showing the global BearerAuth requirement and HTTP bearer scheme

Figure 3: Global authentication. The OpenAPI file requires Bearer authentication by default. The next operation is important because it overrides this setting.

3.4 Local Authentication Override on an Internal Operation

The same contract documented an internal liveness GET operation with security: [] and a 200 response described as runtime metadata. In OpenAPI, this empty operation-level requirement is the key difference: it overrides the global Bearer baseline for that operation. The Internal label alone would not prove a security issue; the authentication exception and later runtime result do.

"/_ops/echo": {
  "get": {
    "summary": "Operational liveness probe. Echoes runtime metadata. Internal use only.",
    "tags": ["Internal"],
    "security": [],
    "responses": {
      "200": { "description": "Runtime metadata." }
    }
  }
}

Focused OpenAPI excerpt showing the internal operation, empty security array, and runtime metadata response

Figure 4: Operation-level override. The empty security array removes authentication from /_ops/echo. The path remains visible for the next request, while the temporary origin is withheld.

3.5 One Unauthenticated Request

The exact documented operation was then opened once in the browser without credentials or input mutation. This is a normalised public representation of the browser request: the documented route is retained, while the live origin is withheld.

R-03: normalised browser request.

GET /_ops/echo HTTP/1.1
Host: <LAB_HOST>

Expected result: JSON runtime metadata without Bearer authentication. No payload is required.

{
  "service": "routing-slip",
  "version": "2.7.1",
  "node": "<REDACTED>",
  "uptime_s": "<REDACTED>",
  "flag": "WEBVERSE{REDACTED}"
}

Sanitized browser response showing runtime metadata and the redacted WebVerse objective

Figure 5: Runtime proof. The documented /_ops/echo operation returned operational metadata and the current objective without credentials. The hostname, node value, uptime, and literal objective are redacted.

4. Runtime Check and False-Positive Controls

ClaimEvidenceNot enough on its own
Developer route was legitimateVisible application navigation and public developer portalA guessed documentation path
OpenAPI was the public contractThe portal directly linked the JSON contractAssuming a conventional /openapi.json route
Bearer authentication was globalFresh contract security and BearerAuth schemeDocumentation prose alone
The internal operation had an auth exceptionOperation-level security: []The Internal tag alone
The operation was unauthenticated at runtimeOne fresh browser GET returned JSON without credentialsSource-only inference or an HTTP status alone
Sensitive effect was presentRuntime metadata and WEBVERSE{REDACTED}A generic health banner

The public OpenAPI document is a discovery amplifier, not the vulnerability by itself. The finding requires both a documented authentication exception and the current unauthenticated runtime effect.

5. Final Result and Historical Completion State

Fresh-instance evidence verifies a public contract, a global Bearer baseline, a local empty-security override on an internal GET operation, and an unauthenticated runtime response containing sensitive metadata. The first objective-containing response ended the reproduction.

The WebVerse challenge had already been marked solved before this fresh evidence session. The available platform image is therefore retained as historical context only, not as proof of fresh objective submission.

Historical WebVerse solved state for Routing Slip

Figure 6: Historical solved state only. This confirms previous platform completion but makes no fresh-submission claim.

6. Root Cause and Classification

The root cause is public exposure of an internal operational function without authentication, combined with a response contract that returns more information than a minimal public health check needs. Publishing the operation and its security: [] exception in the public contract makes the exposure directly discoverable.

ClassificationAssessmentEvidence basis
PrimaryCWE-306: Missing Authentication for Critical FunctionAn internal operation is reachable without authentication.
SecondaryCWE-200: Exposure of Sensitive Information to an Unauthorized ActorThe unauthenticated response includes runtime metadata and objective material.
SeverityNot assignedThe supplied evidence proves the weakness and disclosure, but provides no external severity rubric.

7. Impact and Evidence Limits

Confirmed impact is unauthenticated disclosure from an internal operational endpoint. In a real deployment, analogous metadata can reveal build versions, deployment identifiers, topology hints, dependency state, or debug material; severity depends on the actual response and trust boundary.

No evidence supports claims of customer shipment exposure, cross-tenant access, privileged writes, account takeover, remote code execution, SQL injection, SSRF, or a broader break in the API’s authentication model.

8. Remediation and Validation Guidance

  • Remove internal operational functions from the public origin. Use a private management plane, restricted network boundary, mTLS/service identity, or an authenticated administrative interface.
  • If a public health endpoint is necessary, return only an allowlisted minimal response such as {"status":"ok"}; exclude runtime, build, configuration, and debug values.
  • Publish a customer/partner OpenAPI contract containing only intended public operations. Keep internal management operations in a separate protected contract.
  • Treat public-contract security: [] declarations as policy exceptions requiring explicit review and approval in CI.
  • Add deployment regression tests that compare public routing to an approved allowlist and ensure internal operations return 401/403 or remain network-inaccessible.

A remediation is effective when internal operations are absent from public API documentation, unauthenticated public requests cannot reach them, intentional public health responses match a minimal allowlisted schema, and release review explicitly approves every authentication exception.

Conclusion

Routing Slip shows a simple documentation-led API issue. Public docs linked the OpenAPI file, the file showed an authentication exception on an internal operation, and one unauthenticated GET returned sensitive runtime data. The finding is limited to that read-only path; no wider API capability was tested.