llamaCVEVulnerability Intelligence
/
Advisory · GitHub · npm · @budibase/backend-core

GHSA-M2MM-7XVW-9623

SSRF blacklist bypass: IPv6 unspecified address :: omitted from outbound-fetch default deny list reaches loopback services

Parche disponible
Descargar PNG JSON
CVSS 3.1
5.4
Media
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -31 d de la divulgación
Exposición7 dDesde la divulgación, 12 nov 2026, 3:52 p. m.
Detección5 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 3.49.0
Monitoreo
Detectada +1
12 oct 26
12 nov 26
18 nov 26
19 nov 26
12 oct 26
22 oct 26
31 oct 26
10 nov 26
19 nov 26
FechaFaseEventoDetalle
Remediación Parche 3.49.0 @budibase/backend-core · -31 d desde divulgación
Divulgación Publicada GHSA-M2MM-7XVW-9623 divulgada · CVSS 5.4 (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

Budibase routes outbound HTTP(S) requests (automation steps such as Outgoing Webhook, Zapier, n8n, Slack, Discord, plus the REST datasource, OAuth2 token fetch, query import and object-store import) through a shared allow/deny guard, `fetchWithBlacklist`, which rejects a target when its resolved address matches a hardcoded default deny list. That deny list blocks the IPv6 loopback address `::1/128` but omits the IPv6 unspecified address `::` (`::/128`). Because the operating system routes an outbound connection to `::` onto the IPv6 loopback, an authenticated workspace Builder/Creator who supplies a URL whose host is `[::]` passes the guard and reaches services bound to IPv6 loopback or to a dual-stack wildcard (for example the Budibase server on port 4001 and worker on port 4002), and the response body or error is reflected back into the step or query output. This defeats the server-side request forgery control that the deny list is meant to enforce.

Root Cause

The security invariant is that server-side outbound requests initiated with attacker-influenced URLs must never reach loopback or other internal addresses. The guard enforces this by resolving the target host and rejecting any resolved address that matches the default deny list. The deny list enumerates loopback and private ranges including `127.0.0.0/8`, `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, `100.64.0.0/10`, `169.254.0.0/16`, `0.0.0.0/8`, `::1/128`, `fc00::/7` and `fe80::/10`, but it does not include the IPv6 unspecified address `::` (`::/128`). When the host is `[::]`, the address resolves cleanly to `::`, which matches none of the deny-list entries, so the guard returns "not blocked" and the connection proceeds. The kernel then treats the unspecified destination as the loopback interface, so the request lands on a local service. The guard's own fail-safe branch is not reached, because the address resolves without error; the deny list simply lacks the entry.

Affected component: npm package @budibase/backend-core
File: packages/backend-core/src/blacklist/blacklist.ts
Symbols:
  DEFAULT_BLACKLIST  - the default deny list; lists ::1/128 but omits ::/128
  isBlacklisted      - resolves the host to ["::"] and returns BlockList.check("::","ipv6") === false
Enforcing caller (not the defect site):
  resolveSafePinnedIp / fetchWithBlacklist  - packages/backend-core/src/utils/outboundFetch.ts

Impact

Prerequisites: an authenticated user holding workspace Builder/Creator access (the same actor class the original outbound-fetch hardening was designed to contain), on a deployment where the default deny list is active (that is, a self-hosted deployment has not overridden `BLACKLIST_IPS`, and hosted deployments where the default is always active), and where the host has IPv6 enabled so that `::` routes to loopback. Given those conditions, the attacker obtains a server-side request forgery primitive against services bound to IPv6 loopback or a dual-stack wildcard on the Budibase host. Response bodies and error text are reflected to the caller, giving a read/oracle capability against internal-only services; callers that let the attacker control the HTTP method and body (for example the Outgoing Webhook step) additionally permit constrained write requests to those internal services.

The reachability ceiling is bounded and is reflected in the severity: `::` reaches only IPv6-loopback and `::`-bound (dual-stack) services. It does not reach IPv4-only `127.0.0.1`/`0.0.0.0` binds, and it does not reach the IPv4 cloud metadata endpoint `169.254.169.254` without a NAT64 gateway that is not generally present. On hosts with IPv6 disabled the connection fails. The demonstrated capability is therefore an internal-service read oracle plus constrained internal writes, not full metadata-credential theft.

Proof of Concept

`Requires Node.js (tested on v24). No Budibase deployment is needed to demonstrate the guard gap and the loopback routing; the logic is transcribed verbatim from the affected source and the shipped npm artifact.`

Steps:
1. Reconstruct the default deny list exactly as shipped and build the same `net.BlockList` the guard builds.
2. Check the IPv6 unspecified address against it and observe it is allowed while `::1` and IPv4 loopback are blocked.
3. Start a local HTTP server on the default wildcard bind (Node binds to `::`/dual-stack when IPv6 is available) and issue a request through an agent whose lookup is pinned to `::`, exactly as the guard pins the socket, and observe the internal response is returned.

const net = require("net")
const http = require("http")

const DEFAULT_BLACKLIST = [
  "127.0.0.0/8", "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16",
  "100.64.0.0/10", "169.254.0.0/16", "0.0.0.0/8",
  "::1/128", "fc00::/7", "fe80::/10",
]
const bl = new net.BlockList()
for (const entry of DEFAULT_BLACKLIST) {
  const [ip, prefix] = entry.split("/")
  const fam = net.isIP(ip) === 6 ? "ipv6" : "ipv4"
  bl.addSubnet(ip, Number(prefix), fam)
}
for (const t of ["::", "::1", "127.0.0.1", "0.0.0.0", "169.254.169.254"]) {
  const fam = net.isIP(t) === 6 ? "ipv6" : "ipv4"
  console.log(t, "->", bl.check(t, fam) ? "BLOCKED" : "ALLOWED")
}

const server = http.createServer((_, res) => res.end("INTERNAL-SECRET-DATA"))
server.listen(0, () => {
  const port = server.address().port
  const agent = new http.Agent({
    lookup: (_h, _o, cb) => cb(null, [{ address: "::", family: 6 }]),
  })
  http.get({ host: "localhost", port, agent }, r => {
    let body = ""
    r.on("data", d => (body += d))
    r.on("end", () => { console.log("returned:", body); server.close() })
  })
})
::               -> ALLOWED
::1              -> BLOCKED
127.0.0.1        -> BLOCKED
0.0.0.0          -> BLOCKED
169.254.169.254  -> BLOCKED
returned: INTERNAL-SECRET-DATA

Attack Chain

  1. Exposure: An authenticated Builder/Creator supplies an outbound URL of the form `http://[::]:<port>/` to any feature that routes through the shared outbound-fetch guard (for example the Outgoing Webhook automation step, or a REST datasource base URL).
  2. Control: The URL is parsed by the guard's `parseUrl`, which permits `http:`/`https:` schemes and only rejects embedded credentials. `http://[::]:<port>/` survives unchanged, and the host `[::]` is preserved.
  3. Path: `resolveSafePinnedIp` calls `resolveAddress("[::]")`, which strips the brackets and resolves the host to the single address `::`; the guard then iterates the resolved addresses and calls `isBlacklisted("::")`.
  4. Guard: `isBlacklisted("::")` calls `BlockList.check("::","ipv6")` against the default deny list. `::` matches none of `::1/128`, `fc00::/7` or `fe80::/10`, so the check returns false and the guard treats the target as safe. The address resolves cleanly, so the guard's error fail-safe branch never runs.
  5. Primitive: The guard pins the connecting socket to `::` and performs the request. The kernel routes the unspecified destination to the IPv6 loopback, reaching any service bound to `::`/`::1`/dual-stack on the host.
  6. Result: The response body or error from the internal service is returned in the step or query output, yielding a server-side request forgery read oracle against internal-only services, with constrained internal writes for method/body-controlling callers.

Bypass Evidence

The relevant prior fix is the default deny list itself, introduced to contain server-side request forgery from these outbound paths, and later extended (the shared address space `100.64.0.0/10` was added). This finding shows that fix is incomplete: the deny list adds the IPv6 loopback `::1/128` but never adds the IPv6 unspecified address `::` (`::/128`), which the operating system also routes to loopback.

Evidence and challenges performed:
- The shipped npm artifact `@budibase/backend-core@3.44.1` (latest stable) contains the hardcoded default deny list with `::1/128` and `100.64.0.0/10` present but `::`/`::/128` absent. The same gap is present in every published artifact from `3.34.8` onward, and on the reviewed source tree.
- A `net.BlockList` built from the exact deny list allows `::` while blocking `::1`, `127.0.0.1`, `0.0.0.0` and `169.254.169.254`, confirming `::` is a distinct, unblocked payload.
- Refutation attempt "the IPv4-mapped form `::ffff:127.0.0.1` is the real, already-closed vector so `::` adds nothing": tested and rejected. With the full deny list, Node auto-maps `::ffff:127.0.0.1` against `127.0.0.0/8` and blocks it, so `::` is a genuinely separate gap.
- Refutation attempt "DNS rebinding closes it": rejected. The guard pins the socket to `::` itself, so there is no second-resolution window and none is needed.
- Refutation attempt "the guard fails open rather than truly allowing `::`": rejected. `::` resolves without error, so the guard returns the deny-list check result of false; the failure branch is never entered.

Affected Versions

  • `Ecosystem: npm`
  • `Package: @budibase/backend-core`
  • `Confirmed affected range: >= 3.34.8, <= 3.44.1`
  • `Latest release checked: 3.44.1 (npm registry, published 2026-09-07)`
  • `Fix status: not fixed`

The hardcoded default deny list with `::1/128` but no `::` first shipped in the published artifact `3.34.8` (2026-03-25); the immediately prior published version `3.34.7` did not ship the deny-list module. The gap persists unchanged through the current latest stable `3.44.1`, and no inspected release or branch adds `::`/`::/128`. No fixed release exists, so the range has no upper fix boundary beyond the latest affected published version. The package is consumed by `@budibase/server` and `@budibase/worker`.

Suggested Fix

Enforce that the IPv6 unspecified address cannot be used as an outbound destination. The most direct remediation is to add `::/128` (and, for defense in depth, `::/8`) to the default deny list alongside the existing `::1/128` entry, so the guard blocks it for every caller that routes through `fetchWithBlacklist`. Because the deny list is a single shared control, this one change closes the gap for all automation steps, the REST datasource, OAuth2 token fetch, query import and object-store import simultaneously. Additionally, normalize or explicitly reject the unspecified address in `isBlacklisted`/`resolveSafePinnedIp` so an address that routes to loopback cannot pass regardless of deny-list contents, and consider blocking NAT64 (`64:ff9b::/96`) and 6to4 (`2002::/16`) ranges to prevent indirect reach to IPv4 internal targets. A regression test asserting that `::` is blocked should be added, since the existing blacklist tests cover `::1` and IPv4 loopback but not `::`. Interim mitigation for self-hosted operators: set `BLACKLIST_IPS` to include `::/128`, or disable IPv6 on the host so the unspecified address does not route to loopback.

Reported by zx (GitHub: @manus-pi).

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:L
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida Última
@budibase/backend-core< 3.49.0
3.49.0
4.0.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
npm@budibase/backend-core
Corregida 3.49.0 -31 d 4.0.0 no afectada
Versiones corregidas3.49.0
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/Budibase/budibase/security/advisories/GHSA-m2mm-7xvw-9623

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