llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · @capgo/capgo (capgo.app self-hosted backend)

GHSA-84XQ-4RV7-P252

IDOR in PUT /app icon mints admin-signed URLs for arbitrary paths in the private `images` storage bucket

Sin parche publicado
Descargar PNG JSON
CVSS 3.1
4.3
Media
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición72 dDesde la divulgación, 8 sept 2026, 9:20 a. m.
Detección71 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
8 sept 26
18 nov 26
19 nov 26
8 sept 26
26 sept 26
14 oct 26
1 nov 26
19 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-84XQ-4RV7-P252 divulgada · CVSS 4.3 (GitHub)
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

The `PUT /app/:appId` endpoint accepts an attacker-controlled `body.icon` storage path, persists it, then asks Supabase's service-role client to mint a 7-day signed URL for that path. Because the service role bypasses Storage RLS, an authenticated user can obtain unauthenticated, time-limited download URLs for any object in the `images` bucket — including avatars, org logos and app icons belonging to other users and organizations — even though the bucket was made private precisely to prevent cross-tenant reads.

Details

The images bucket was switched to `public = false` in `supabase/migrations/20260130033703_private_images_bucket.sql`, with RLS policies that restrict each user/org to its own folder. Reads against the storage HTTP API therefore require either RLS-allowed access or a service-role-signed URL.

`PUT /app/:appId` (`supabase/functions/_backend/public/app/put.ts`) only checks the caller against the `appId` they are updating; it never constrains the `icon` field:

// supabase/functions/_backend/public/app/put.ts:34
if (!(await checkPermission(c, 'app.update_settings', { appId }))) {
  throw quickError(401, 'cannot_access_app', 'You can\'t access this app', { app_id: appId })
}
...
// put.ts:55, 67
const normalizedIcon = normalizeImagePath(body.icon)
...
.update({
  ...
  icon_url: normalizedIcon ?? body.icon,
  ...
})

`normalizeImagePath` (`supabase/functions/_backend/utils/storage.ts:7`) is a string-shape helper, not a validator. For non-URL inputs it strips an optional leading `images/` and leading slashes and returns the rest verbatim:

return trimmed.replace(/^images\//, '').replace(/^\/+/, '')

After persistence, the handler immediately mints and returns a signed URL via the service-role client:

// put.ts:91-94
if (data.icon_url) {
  const signedIcon = await createSignedImageUrl(c, data.icon_url)
  data.icon_url = signedIcon ?? ''
}
// supabase/functions/_backend/utils/storage.ts:29-49
export async function createSignedImageUrl(c: Context, rawPath?: string | null) {
  ...
  const { data, error } = await supabaseAdmin(c)
    .storage
    .from('images')
    .createSignedUrl(normalized, SIGNED_URL_TTL_SECONDS) // 7 days
  ...
  return data.signedUrl
}

`supabaseAdmin` is the service-role client; calls through it bypass `storage.objects` RLS. The result is that any path the attacker can name in the private `images` bucket is signable. Per the existing layout (see `cron_clean_orphan_images.ts`, `on_user_delete.ts`, `on_organization_delete.ts`, `on_app_delete.ts`):

  • `<user_id>/<filename>` — user avatars (referenced by `users.image_url`)
  • `org/<org_id>/logo/<filename>` — organization logos
  • `org/<org_id>/<app_id>/icon` — app icons (reverse-domain `app_id` is often easy to guess)

Path knowledge is cheap: org IDs are exposed to any member, app IDs are reverse-domain strings often visible publicly, and user IDs are surfaced through normal team/org UIs. The endpoint is the only authorization gate, and it does not gate the path.

A secondary side-effect amplifies the issue: the `on_app_update` trigger calls `cleanStoredImageMetadata(record.icon_url)` (`supabase/functions/_backend/triggers/on_app_update.ts:20`), which downloads the object via service role and re-uploads it with EXIF/metadata stripped (`supabase/functions/_backend/utils/image.ts:163-205`). Pointing `icon_url` at a victim's avatar therefore also rewrites the victim's stored avatar with a metadata-stripped copy.

PoC

Pre-conditions: any account that owns at least one app (`com.attacker.myapp`). Target a known image path, e.g. an org logo `org/<victim_org_id>/logo/logo.png` (org IDs are visible to any member of that org and often leak via support / share flows; for this PoC use any path you legitimately know exists).

  1. Authenticate and call `PUT /app/com.attacker.myapp` with the target path:
curl -sS -X PUT https://api.capgo.app/app/com.attacker.myapp \
     -H 'Authorization: <attacker_jwt_or_apikey>' \
     -H 'Content-Type: application/json' \
     -d '{"icon":"<victim_user_uuid>/avatar.png"}'
  1. The JSON response includes `icon_url` set to a Supabase Storage signed URL of the form:
https://<project>.supabase.co/storage/v1/object/sign/images/<victim_user_uuid>/avatar.png?token=<jwt>
  1. Fetch the signed URL with no authentication:
curl -sS -o stolen.png "https://<project>.supabase.co/storage/v1/object/sign/images/<victim_user_uuid>/avatar.png?token=<jwt>"

`stolen.png` is the victim's avatar bytes, served despite the bucket being private. The token is valid for 7 days (`SIGNED_URL_TTL_SECONDS = 60 * 60 * 24 * 7` in `storage.ts:4`).

The same flow works for `org/<other_org_id>/logo/<file>` and `org/<other_org_id>/<other_app_id>/icon`, crossing organization boundaries entirely.

Impact

  • Cross-tenant read of any object in the private `images` bucket: user avatars (PII), organization logos, app icons.
  • The signed URL is valid for 7 days and requires no auth, enabling out-of-band exfiltration and sharing.
  • Triggered side-effect: `on_app_update` runs `cleanStoredImageMetadata` against the attacker-supplied path, rewriting the victim's stored object with a metadata-stripped copy (low-grade integrity impact on victim-owned images).
  • Defeats the security goal of the `20260130033703_private_images_bucket.sql` migration that made the bucket private and added per-user/per-org RLS.

The privilege bar is low — anyone who can create or already owns an app in any organization on the instance can exploit it.

Recommended Fix

Constrain `body.icon` to paths the caller is authorized to write, i.e. the icon path of the app being updated. Two layered fixes:

  1. In `supabase/functions/_backend/public/app/put.ts`, before persisting/signing, reject any path that is not under `org/<owner_org>/<appId>/`:
function isAllowedAppIconPath(path: string, ownerOrg: string, appId: string): boolean {
  const prefix = `org/${ownerOrg}/${appId}/`
  return path === `${prefix}icon` || path.startsWith(prefix)
}

const normalizedIcon = normalizeImagePath(body.icon)
if (normalizedIcon && !isAllowedAppIconPath(normalizedIcon, previousApp.owner_org, appId)) {
  throw quickError(400, 'invalid_icon_path', 'icon must reference this app\'s storage folder')
}

Apply the equivalent guard in `supabase/functions/_backend/public/app/post.ts` (which has the identical pattern) and any other endpoint that accepts a user-supplied storage path and signs it via `supabaseAdmin`.

  1. Harden `createSignedImageUrl` (`supabase/functions/_backend/utils/storage.ts`) so it cannot be used as a generic signing oracle — accept an explicit `{ kind: 'user'|'org-logo'|'app-icon', ownerId, appId? }` descriptor and build the path inside the function, rather than accepting an arbitrary string. Callers should never be able to influence which path is signed except through validated identifiers.
  1. Optional defense in depth: have the trigger / handler verify the storage object's owner (`storage.objects.owner` / metadata) matches `previousApp.owner_org` before signing.

<!-- private-maintainer-note -->
Private maintainer note: likely mitigated by merged PR https://github.com/Cap-go/capgo.app/pull/3083 (signed image URL ownership scoped to org logo vs app paths). Reporter: please re-test on latest main; if still reproducible, comment with updated PoC.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:L
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:L
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida
@capgo/capgo (capgo.app self-hosted backend)≤ 12.128.2
12.128.2
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npm@capgo/capgo (capgo.app self-hosted backend)
Sin parche — — —
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/Cap-go/capgo.app/security/advisories/GHSA-84xq-4rv7-p252

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.