Your RSA-2048 keys break in 2030. Find every one of them before attackers do.
🐹 Go

GHSA-cxx3-hr75-4q96

GHSA-cxx3-hr75-4q96 is a CWE-862 vulnerability in github.com/getarcaneapp/arcane/backend. O3 Security confirms whether GHSA-cxx3-hr75-4q96 is actually reachable in your code before you act, and blocks exploitation at runtime until you patch.

Arcane Vulnerable to Unauthenticated Disclosure of Custom Compose Template Content (incl. `.env` secrets)

Also known asCVE-2026-42461GO-2026-5340
Published
Apr 30, 2026
Updated
Jun 25, 2026
Affected
1 pkg
Patched
1 / 1
Exploits
None indexed

Blast Radius

1 pkg affected
🐹github.com/getarcaneapp/arcane/backend

Real-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages — download data is not available via public APIs for these ecosystems.

Description

Summary

Four GET endpoints under /api/templates* in Arcane's Huma backend are registered without any Security requirement, allowing any unauthenticated network client to list and read the full Compose YAML and .env content of every custom template stored in the instance. Because Arcane's UI exposes a "Save as Template" flow on the project / swarm-stack creation pages that persists the operator's real env content (database passwords, API keys, etc.) verbatim, this missing authorization is an unauthenticated read of operator secrets in practice — not a theoretical info-disclosure.

The frontend explicitly treats /customize/templates/* as an authenticated area (PROTECTED_PREFIXES in frontend/src/lib/utils/redirect.util.ts), and every CRUD operation (POST/PUT/DELETE) on the same paths requires a Bearer/API key, so this is a clear backend authorization gap, not intended public access.

Details

Affected file: backend/internal/huma/handlers/templates.go:194-228.

In RegisterTemplates, four huma.Register calls have no Security: block:

// templates.go
huma.Register(api, huma.Operation{
    OperationID: "listTemplatesPaginated",
    Method:      "GET",
    Path:        "/templates",
    ...
    // <-- no Security
}, h.ListTemplates)

huma.Register(api, huma.Operation{
    OperationID: "getAllTemplates",
    Method:      "GET",
    Path:        "/templates/all",
    ...
}, h.GetAllTemplates)

huma.Register(api, huma.Operation{
    OperationID: "getTemplate",
    Method:      "GET",
    Path:        "/templates/{id}",
    ...
}, h.GetTemplate)

huma.Register(api, huma.Operation{
    OperationID: "getTemplateContent",
    Method:      "GET",
    Path:        "/templates/{id}/content",
    ...
}, h.GetTemplateContent)

Arcane's auth bridge (backend/internal/huma/middleware/auth.go:168-172) only enforces authentication when the operation declares one of the security schemes (BearerAuth or ApiKeyAuth). With Security omitted, parseSecurityRequirements returns isRequired=false and the request flows through with no token check.

TemplateHandler.GetTemplateContent (templates.go:478-499) calls templateService.GetTemplateContentWithParsedData (backend/internal/services/template_service.go:1303-1347), which returns the model's Content, EnvContent, parsed services, and parsed env-variable key/value pairs verbatim. The model models.ComposeTemplate (backend/internal/models/template.go:15-16) stores Content and EnvContent as plain text columns and has no owner / user binding.

Impact

  • Pre-auth confidentiality breach. An unauthenticated client on the same network (or through any path-unaware reverse proxy) recovers the full envContent of every locally-stored Compose template. Because the supported "Save as Template" workflow takes the operator's real env values verbatim, this commonly includes database passwords, registry tokens, third-party API keys (Stripe, Sentry, etc.), and OIDC client secrets.
  • Internal asset enumeration. GET /api/templates returns names, descriptions, tags, and registry metadata for every template, leaking what services the team runs internally and which compose files they reuse

Affected Packages

1 total 1 fixed
EcosystemPackageVulnerable rangeFix
🐹Gogithub.com/getarcaneapp/arcane/backendall versions1.18.0

Detection & mitigation playbook

Open-source dependency
  1. Detect

    Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/getarcaneapp/arcane/backend. O3's reachability analysis confirms whether the vulnerable code path is actually invoked in your application, so you act on real exposure instead of every transitive match.

  2. Fix

    Update github.com/getarcaneapp/arcane/backend to 1.18.0 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms GHSA-cxx3-hr75-4q96 is resolved across your whole dependency graph.

  3. Workarounds

    If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.

  4. How O3 protects you

    O3 pinpoints whether GHSA-cxx3-hr75-4q96 is reachable in your code and exactly where to fix it, then blocks exploitation in production at runtime until the patched version is deployed.

Tailored to GHSA-cxx3-hr75-4q96. Runtime protection reduces exposure until a permanent patch is applied and verified — it complements patching, it doesn't replace it.

Frequently Asked Questions

### Summary Four `GET` endpoints under `/api/templates*` in Arcane's Huma backend are registered without any `Security` requirement, allowing any unauthenticated network client to list and read the full Compose YAML and `.env` content of every custom template stored in the instance. Because Arcane's UI exposes a "Save as Template" flow on the project / swarm-stack creation pages that persists the operator's *real* env content (database passwords, API keys, etc.) verbatim, this missing authorization is an unauthenticated read of operator secrets in practice — not a theoretical info-disclosure.
O3 Security · Impact-Aware SCA

Is GHSA-cxx3-hr75-4q96 in your dependencies?

O3 detects GHSA-cxx3-hr75-4q96 across Go dependencies and uses function-level reachability to confirm whether the vulnerable code path is actually reachable — not just present. No false positives.